1#![warn(clippy::all)]
3#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]
4
5pub mod natural {
6
7 pub use fidl_next_common_fuchsia_component::natural::*;
8
9 #[doc = " Payload for CapabilityRequested events\n"]
10 #[derive(Debug, Default, PartialEq)]
11 pub struct CapabilityRequestedPayload {
12 pub name: ::core::option::Option<::std::string::String>,
13
14 pub capability: ::core::option::Option<::fidl_next::fuchsia::zx::Channel>,
15 }
16
17 impl CapabilityRequestedPayload {
18 fn __max_ordinal(&self) -> usize {
19 if self.capability.is_some() {
20 return 2;
21 }
22
23 if self.name.is_some() {
24 return 1;
25 }
26
27 0
28 }
29 }
30
31 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CapabilityRequestedPayload<'static>, ___E>
32 for CapabilityRequestedPayload
33 where
34 ___E: ::fidl_next::Encoder + ?Sized,
35 ___E: ::fidl_next::fuchsia::HandleEncoder,
36 {
37 #[inline]
38 fn encode(
39 mut self,
40 encoder: &mut ___E,
41 out: &mut ::core::mem::MaybeUninit<crate::wire::CapabilityRequestedPayload<'static>>,
42 _: (),
43 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
44 ::fidl_next::munge!(let crate::wire::CapabilityRequestedPayload { table } = out);
45
46 let max_ord = self.__max_ordinal();
47
48 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
49 ::fidl_next::Wire::zero_padding(&mut out);
50
51 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
52 ::fidl_next::wire::Envelope,
53 >(encoder, max_ord);
54
55 for i in 1..=max_ord {
56 match i {
57 2 => {
58 if let Some(value) = self.capability.take() {
59 ::fidl_next::wire::Envelope::encode_value::<
60 ::fidl_next::wire::fuchsia::Channel,
61 ___E,
62 >(
63 value, preallocated.encoder, &mut out, ()
64 )?;
65 } else {
66 ::fidl_next::wire::Envelope::encode_zero(&mut out)
67 }
68 }
69
70 1 => {
71 if let Some(value) = self.name.take() {
72 ::fidl_next::wire::Envelope::encode_value::<
73 ::fidl_next::wire::String<'static>,
74 ___E,
75 >(
76 value, preallocated.encoder, &mut out, 255
77 )?;
78 } else {
79 ::fidl_next::wire::Envelope::encode_zero(&mut out)
80 }
81 }
82
83 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
84 }
85 unsafe {
86 preallocated.write_next(out.assume_init_ref());
87 }
88 }
89
90 ::fidl_next::wire::Table::encode_len(table, max_ord);
91
92 Ok(())
93 }
94 }
95
96 impl<'de> ::fidl_next::FromWire<crate::wire::CapabilityRequestedPayload<'de>>
97 for CapabilityRequestedPayload
98 {
99 #[inline]
100 fn from_wire(wire_: crate::wire::CapabilityRequestedPayload<'de>) -> Self {
101 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
102
103 let name = wire_.table.get(1);
104
105 let capability = wire_.table.get(2);
106
107 Self {
108 name: name.map(|envelope| {
109 ::fidl_next::FromWire::from_wire(unsafe {
110 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
111 })
112 }),
113
114 capability: capability.map(|envelope| {
115 ::fidl_next::FromWire::from_wire(unsafe {
116 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Channel>()
117 })
118 }),
119 }
120 }
121 }
122
123 #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
124 #[repr(C)]
125 pub struct ControllerIsStartedResponse {
126 pub is_started: bool,
127 }
128
129 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ControllerIsStartedResponse, ___E>
130 for ControllerIsStartedResponse
131 where
132 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
133 ___E: ::fidl_next::fuchsia::HandleEncoder,
134 {
135 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
136 Self,
137 crate::wire::ControllerIsStartedResponse,
138 > = unsafe {
139 ::fidl_next::CopyOptimization::enable_if(
140 true && <bool as ::fidl_next::Encode<bool, ___E>>::COPY_OPTIMIZATION.is_enabled(),
141 )
142 };
143
144 #[inline]
145 fn encode(
146 self,
147 encoder_: &mut ___E,
148 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerIsStartedResponse>,
149 _: (),
150 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
151 ::fidl_next::munge! {
152 let crate::wire::ControllerIsStartedResponse {
153 is_started,
154
155 } = out_;
156 }
157
158 ::fidl_next::Encode::encode(self.is_started, encoder_, is_started, ())?;
159
160 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(is_started.as_mut_ptr()) };
161
162 Ok(())
163 }
164 }
165
166 unsafe impl<___E>
167 ::fidl_next::EncodeOption<
168 ::fidl_next::wire::Box<'static, crate::wire::ControllerIsStartedResponse>,
169 ___E,
170 > for ControllerIsStartedResponse
171 where
172 ___E: ::fidl_next::Encoder + ?Sized,
173 ControllerIsStartedResponse:
174 ::fidl_next::Encode<crate::wire::ControllerIsStartedResponse, ___E>,
175 {
176 #[inline]
177 fn encode_option(
178 this: ::core::option::Option<Self>,
179 encoder: &mut ___E,
180 out: &mut ::core::mem::MaybeUninit<
181 ::fidl_next::wire::Box<'static, crate::wire::ControllerIsStartedResponse>,
182 >,
183 _: (),
184 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
185 if let Some(inner) = this {
186 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
187 ::fidl_next::wire::Box::encode_present(out);
188 } else {
189 ::fidl_next::wire::Box::encode_absent(out);
190 }
191
192 Ok(())
193 }
194 }
195
196 impl ::fidl_next::FromWire<crate::wire::ControllerIsStartedResponse>
197 for ControllerIsStartedResponse
198 {
199 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
200 crate::wire::ControllerIsStartedResponse,
201 Self,
202 > = unsafe {
203 ::fidl_next::CopyOptimization::enable_if(
204 true && <bool as ::fidl_next::FromWire<bool>>::COPY_OPTIMIZATION.is_enabled(),
205 )
206 };
207
208 #[inline]
209 fn from_wire(wire: crate::wire::ControllerIsStartedResponse) -> Self {
210 Self { is_started: ::fidl_next::FromWire::from_wire(wire.is_started) }
211 }
212 }
213
214 #[derive(Debug, PartialEq)]
215 #[repr(C)]
216 pub struct ControllerGetExposedDictionaryResponse {
217 pub dictionary: ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef,
218 }
219
220 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ControllerGetExposedDictionaryResponse, ___E>
221 for ControllerGetExposedDictionaryResponse
222 where
223 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
224 ___E: ::fidl_next::fuchsia::HandleEncoder,
225 {
226 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
227 Self,
228 crate::wire::ControllerGetExposedDictionaryResponse,
229 > = unsafe {
230 ::fidl_next::CopyOptimization::enable_if(
231 true
232
233 && <
234 ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef as ::fidl_next::Encode<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef, ___E>
235 >::COPY_OPTIMIZATION.is_enabled()
236
237 )
238 };
239
240 #[inline]
241 fn encode(
242 self,
243 encoder_: &mut ___E,
244 out_: &mut ::core::mem::MaybeUninit<
245 crate::wire::ControllerGetExposedDictionaryResponse,
246 >,
247 _: (),
248 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
249 ::fidl_next::munge! {
250 let crate::wire::ControllerGetExposedDictionaryResponse {
251 dictionary,
252
253 } = out_;
254 }
255
256 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
257
258 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dictionary.as_mut_ptr()) };
259
260 Ok(())
261 }
262 }
263
264 unsafe impl<___E>
265 ::fidl_next::EncodeOption<
266 ::fidl_next::wire::Box<'static, crate::wire::ControllerGetExposedDictionaryResponse>,
267 ___E,
268 > for ControllerGetExposedDictionaryResponse
269 where
270 ___E: ::fidl_next::Encoder + ?Sized,
271 ControllerGetExposedDictionaryResponse:
272 ::fidl_next::Encode<crate::wire::ControllerGetExposedDictionaryResponse, ___E>,
273 {
274 #[inline]
275 fn encode_option(
276 this: ::core::option::Option<Self>,
277 encoder: &mut ___E,
278 out: &mut ::core::mem::MaybeUninit<
279 ::fidl_next::wire::Box<
280 'static,
281 crate::wire::ControllerGetExposedDictionaryResponse,
282 >,
283 >,
284 _: (),
285 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
286 if let Some(inner) = this {
287 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
288 ::fidl_next::wire::Box::encode_present(out);
289 } else {
290 ::fidl_next::wire::Box::encode_absent(out);
291 }
292
293 Ok(())
294 }
295 }
296
297 impl ::fidl_next::FromWire<crate::wire::ControllerGetExposedDictionaryResponse>
298 for ControllerGetExposedDictionaryResponse
299 {
300 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
301 crate::wire::ControllerGetExposedDictionaryResponse,
302 Self,
303 > = unsafe {
304 ::fidl_next::CopyOptimization::enable_if(
305 true
306
307 && <
308 ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef as ::fidl_next::FromWire<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
309 >::COPY_OPTIMIZATION.is_enabled()
310
311 )
312 };
313
314 #[inline]
315 fn from_wire(wire: crate::wire::ControllerGetExposedDictionaryResponse) -> Self {
316 Self { dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary) }
317 }
318 }
319
320 #[derive(Debug, PartialEq)]
321 #[repr(C)]
322 pub struct ControllerGetOutputDictionaryResponse {
323 pub dictionary: ::fidl_next::fuchsia::zx::EventPair,
324 }
325
326 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ControllerGetOutputDictionaryResponse, ___E>
327 for ControllerGetOutputDictionaryResponse
328 where
329 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
330 ___E: ::fidl_next::fuchsia::HandleEncoder,
331 {
332 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
333 Self,
334 crate::wire::ControllerGetOutputDictionaryResponse,
335 > = unsafe {
336 ::fidl_next::CopyOptimization::enable_if(
337 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
338 ::fidl_next::wire::fuchsia::EventPair,
339 ___E,
340 >>::COPY_OPTIMIZATION
341 .is_enabled(),
342 )
343 };
344
345 #[inline]
346 fn encode(
347 self,
348 encoder_: &mut ___E,
349 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerGetOutputDictionaryResponse>,
350 _: (),
351 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
352 ::fidl_next::munge! {
353 let crate::wire::ControllerGetOutputDictionaryResponse {
354 dictionary,
355
356 } = out_;
357 }
358
359 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
360
361 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dictionary.as_mut_ptr()) };
362
363 Ok(())
364 }
365 }
366
367 unsafe impl<___E>
368 ::fidl_next::EncodeOption<
369 ::fidl_next::wire::Box<'static, crate::wire::ControllerGetOutputDictionaryResponse>,
370 ___E,
371 > for ControllerGetOutputDictionaryResponse
372 where
373 ___E: ::fidl_next::Encoder + ?Sized,
374 ControllerGetOutputDictionaryResponse:
375 ::fidl_next::Encode<crate::wire::ControllerGetOutputDictionaryResponse, ___E>,
376 {
377 #[inline]
378 fn encode_option(
379 this: ::core::option::Option<Self>,
380 encoder: &mut ___E,
381 out: &mut ::core::mem::MaybeUninit<
382 ::fidl_next::wire::Box<'static, crate::wire::ControllerGetOutputDictionaryResponse>,
383 >,
384 _: (),
385 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
386 if let Some(inner) = this {
387 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
388 ::fidl_next::wire::Box::encode_present(out);
389 } else {
390 ::fidl_next::wire::Box::encode_absent(out);
391 }
392
393 Ok(())
394 }
395 }
396
397 impl ::fidl_next::FromWire<crate::wire::ControllerGetOutputDictionaryResponse>
398 for ControllerGetOutputDictionaryResponse
399 {
400 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
401 crate::wire::ControllerGetOutputDictionaryResponse,
402 Self,
403 > = unsafe {
404 ::fidl_next::CopyOptimization::enable_if(
405 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
406 ::fidl_next::wire::fuchsia::EventPair,
407 >>::COPY_OPTIMIZATION
408 .is_enabled(),
409 )
410 };
411
412 #[inline]
413 fn from_wire(wire: crate::wire::ControllerGetOutputDictionaryResponse) -> Self {
414 Self { dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary) }
415 }
416 }
417
418 #[doc = " A single component namespace entry, which describes a namespace mount point\n (`path`) and the directory backing it (`directory`). This type is usually\n composed inside a vector. See `ComponentStartInfo.ns` for more details.\n"]
419 #[derive(Debug, Default, PartialEq)]
420 pub struct NamespaceEntry {
421 pub path: ::core::option::Option<::std::string::String>,
422
423 pub directory: ::core::option::Option<
424 ::fidl_next::ClientEnd<
425 ::fidl_next_fuchsia_io::Directory,
426 ::fidl_next::fuchsia::zx::Channel,
427 >,
428 >,
429 }
430
431 impl NamespaceEntry {
432 fn __max_ordinal(&self) -> usize {
433 if self.directory.is_some() {
434 return 2;
435 }
436
437 if self.path.is_some() {
438 return 1;
439 }
440
441 0
442 }
443 }
444
445 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceEntry<'static>, ___E> for NamespaceEntry
446 where
447 ___E: ::fidl_next::Encoder + ?Sized,
448 ___E: ::fidl_next::fuchsia::HandleEncoder,
449 {
450 #[inline]
451 fn encode(
452 mut self,
453 encoder: &mut ___E,
454 out: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceEntry<'static>>,
455 _: (),
456 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
457 ::fidl_next::munge!(let crate::wire::NamespaceEntry { table } = out);
458
459 let max_ord = self.__max_ordinal();
460
461 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
462 ::fidl_next::Wire::zero_padding(&mut out);
463
464 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
465 ::fidl_next::wire::Envelope,
466 >(encoder, max_ord);
467
468 for i in 1..=max_ord {
469 match i {
470 2 => {
471 if let Some(value) = self.directory.take() {
472 ::fidl_next::wire::Envelope::encode_value::<
473 ::fidl_next::ClientEnd<
474 ::fidl_next_fuchsia_io::Directory,
475 ::fidl_next::wire::fuchsia::Channel,
476 >,
477 ___E,
478 >(
479 value, preallocated.encoder, &mut out, ()
480 )?;
481 } else {
482 ::fidl_next::wire::Envelope::encode_zero(&mut out)
483 }
484 }
485
486 1 => {
487 if let Some(value) = self.path.take() {
488 ::fidl_next::wire::Envelope::encode_value::<
489 ::fidl_next::wire::String<'static>,
490 ___E,
491 >(
492 value, preallocated.encoder, &mut out, 4095
493 )?;
494 } else {
495 ::fidl_next::wire::Envelope::encode_zero(&mut out)
496 }
497 }
498
499 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
500 }
501 unsafe {
502 preallocated.write_next(out.assume_init_ref());
503 }
504 }
505
506 ::fidl_next::wire::Table::encode_len(table, max_ord);
507
508 Ok(())
509 }
510 }
511
512 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceEntry<'de>> for NamespaceEntry {
513 #[inline]
514 fn from_wire(wire_: crate::wire::NamespaceEntry<'de>) -> Self {
515 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
516
517 let path = wire_.table.get(1);
518
519 let directory = wire_.table.get(2);
520
521 Self {
522 path: path.map(|envelope| {
523 ::fidl_next::FromWire::from_wire(unsafe {
524 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
525 })
526 }),
527
528 directory: directory.map(|envelope| {
529 ::fidl_next::FromWire::from_wire(unsafe {
530 envelope.read_unchecked::<::fidl_next::ClientEnd<
531 ::fidl_next_fuchsia_io::Directory,
532 ::fidl_next::wire::fuchsia::Channel,
533 >>()
534 })
535 }),
536 }
537 }
538 }
539
540 #[derive(Debug, Default, PartialEq)]
541 pub struct StartChildArgs {
542 pub numbered_handles: ::core::option::Option<
543 ::std::vec::Vec<::fidl_next_fuchsia_process::natural::HandleInfo>,
544 >,
545
546 pub namespace_entries:
547 ::core::option::Option<::std::vec::Vec<crate::natural::NamespaceEntry>>,
548
549 pub dictionary:
550 ::core::option::Option<::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef>,
551
552 pub additional_inputs: ::core::option::Option<::fidl_next::fuchsia::zx::EventPair>,
553 }
554
555 impl StartChildArgs {
556 fn __max_ordinal(&self) -> usize {
557 if self.additional_inputs.is_some() {
558 return 4;
559 }
560
561 if self.dictionary.is_some() {
562 return 3;
563 }
564
565 if self.namespace_entries.is_some() {
566 return 2;
567 }
568
569 if self.numbered_handles.is_some() {
570 return 1;
571 }
572
573 0
574 }
575 }
576
577 unsafe impl<___E> ::fidl_next::Encode<crate::wire::StartChildArgs<'static>, ___E> for StartChildArgs
578 where
579 ___E: ::fidl_next::Encoder + ?Sized,
580 ___E: ::fidl_next::fuchsia::HandleEncoder,
581 {
582 #[inline]
583 fn encode(
584 mut self,
585 encoder: &mut ___E,
586 out: &mut ::core::mem::MaybeUninit<crate::wire::StartChildArgs<'static>>,
587 _: (),
588 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
589 ::fidl_next::munge!(let crate::wire::StartChildArgs { table } = out);
590
591 let max_ord = self.__max_ordinal();
592
593 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
594 ::fidl_next::Wire::zero_padding(&mut out);
595
596 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
597 ::fidl_next::wire::Envelope,
598 >(encoder, max_ord);
599
600 for i in 1..=max_ord {
601 match i {
602 4 => {
603 if let Some(value) = self.additional_inputs.take() {
604 ::fidl_next::wire::Envelope::encode_value::<
605 ::fidl_next::wire::fuchsia::EventPair,
606 ___E,
607 >(
608 value, preallocated.encoder, &mut out, ()
609 )?;
610 } else {
611 ::fidl_next::wire::Envelope::encode_zero(&mut out)
612 }
613 }
614
615 3 => {
616 if let Some(value) = self.dictionary.take() {
617 ::fidl_next::wire::Envelope::encode_value::<
618 ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
619 ___E,
620 >(
621 value, preallocated.encoder, &mut out, ()
622 )?;
623 } else {
624 ::fidl_next::wire::Envelope::encode_zero(&mut out)
625 }
626 }
627
628 2 => {
629 if let Some(value) = self.namespace_entries.take() {
630 ::fidl_next::wire::Envelope::encode_value::<
631 ::fidl_next::wire::Vector<
632 'static,
633 crate::wire::NamespaceEntry<'static>,
634 >,
635 ___E,
636 >(
637 value, preallocated.encoder, &mut out, (32, ())
638 )?;
639 } else {
640 ::fidl_next::wire::Envelope::encode_zero(&mut out)
641 }
642 }
643
644 1 => {
645 if let Some(value) = self.numbered_handles.take() {
646 ::fidl_next::wire::Envelope::encode_value::<
647 ::fidl_next::wire::Vector<
648 'static,
649 ::fidl_next_fuchsia_process::wire::HandleInfo,
650 >,
651 ___E,
652 >(
653 value, preallocated.encoder, &mut out, (128, ())
654 )?;
655 } else {
656 ::fidl_next::wire::Envelope::encode_zero(&mut out)
657 }
658 }
659
660 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
661 }
662 unsafe {
663 preallocated.write_next(out.assume_init_ref());
664 }
665 }
666
667 ::fidl_next::wire::Table::encode_len(table, max_ord);
668
669 Ok(())
670 }
671 }
672
673 impl<'de> ::fidl_next::FromWire<crate::wire::StartChildArgs<'de>> for StartChildArgs {
674 #[inline]
675 fn from_wire(wire_: crate::wire::StartChildArgs<'de>) -> Self {
676 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
677
678 let numbered_handles = wire_.table.get(1);
679
680 let namespace_entries = wire_.table.get(2);
681
682 let dictionary = wire_.table.get(3);
683
684 let additional_inputs = wire_.table.get(4);
685
686 Self {
687
688
689 numbered_handles: numbered_handles.map(|envelope| ::fidl_next::FromWire::from_wire(
690 unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>>() }
691 )),
692
693
694 namespace_entries: namespace_entries.map(|envelope| ::fidl_next::FromWire::from_wire(
695 unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>>() }
696 )),
697
698
699 dictionary: dictionary.map(|envelope| ::fidl_next::FromWire::from_wire(
700 unsafe { envelope.read_unchecked::<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>() }
701 )),
702
703
704 additional_inputs: additional_inputs.map(|envelope| ::fidl_next::FromWire::from_wire(
705 unsafe { envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>() }
706 )),
707
708 }
709 }
710 }
711
712 #[derive(Debug, PartialEq)]
713 pub struct ControllerStartRequest {
714 pub args: crate::natural::StartChildArgs,
715
716 pub execution_controller:
717 ::fidl_next::ServerEnd<crate::ExecutionController, ::fidl_next::fuchsia::zx::Channel>,
718 }
719
720 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ControllerStartRequest<'static>, ___E>
721 for ControllerStartRequest
722 where
723 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
724 ___E: ::fidl_next::Encoder,
725 ___E: ::fidl_next::fuchsia::HandleEncoder,
726 {
727 #[inline]
728 fn encode(
729 self,
730 encoder_: &mut ___E,
731 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerStartRequest<'static>>,
732 _: (),
733 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
734 ::fidl_next::munge! {
735 let crate::wire::ControllerStartRequest {
736 args,
737 execution_controller,
738
739 } = out_;
740 }
741
742 ::fidl_next::Encode::encode(self.args, encoder_, args, ())?;
743
744 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(args.as_mut_ptr()) };
745
746 ::fidl_next::Encode::encode(
747 self.execution_controller,
748 encoder_,
749 execution_controller,
750 (),
751 )?;
752
753 let mut _field =
754 unsafe { ::fidl_next::Slot::new_unchecked(execution_controller.as_mut_ptr()) };
755
756 Ok(())
757 }
758 }
759
760 unsafe impl<___E>
761 ::fidl_next::EncodeOption<
762 ::fidl_next::wire::Box<'static, crate::wire::ControllerStartRequest<'static>>,
763 ___E,
764 > for ControllerStartRequest
765 where
766 ___E: ::fidl_next::Encoder + ?Sized,
767 ControllerStartRequest:
768 ::fidl_next::Encode<crate::wire::ControllerStartRequest<'static>, ___E>,
769 {
770 #[inline]
771 fn encode_option(
772 this: ::core::option::Option<Self>,
773 encoder: &mut ___E,
774 out: &mut ::core::mem::MaybeUninit<
775 ::fidl_next::wire::Box<'static, crate::wire::ControllerStartRequest<'static>>,
776 >,
777 _: (),
778 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
779 if let Some(inner) = this {
780 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
781 ::fidl_next::wire::Box::encode_present(out);
782 } else {
783 ::fidl_next::wire::Box::encode_absent(out);
784 }
785
786 Ok(())
787 }
788 }
789
790 impl<'de> ::fidl_next::FromWire<crate::wire::ControllerStartRequest<'de>>
791 for ControllerStartRequest
792 {
793 #[inline]
794 fn from_wire(wire: crate::wire::ControllerStartRequest<'de>) -> Self {
795 Self {
796 args: ::fidl_next::FromWire::from_wire(wire.args),
797
798 execution_controller: ::fidl_next::FromWire::from_wire(wire.execution_controller),
799 }
800 }
801 }
802
803 #[derive(Debug, PartialEq)]
804 #[repr(C)]
805 pub struct ControllerOpenExposedDirRequest {
806 pub exposed_dir: ::fidl_next::ServerEnd<
807 ::fidl_next_fuchsia_io::Directory,
808 ::fidl_next::fuchsia::zx::Channel,
809 >,
810 }
811
812 unsafe impl<___E> ::fidl_next::Encode<crate::wire::ControllerOpenExposedDirRequest, ___E>
813 for ControllerOpenExposedDirRequest
814 where
815 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
816 ___E: ::fidl_next::fuchsia::HandleEncoder,
817 {
818 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
819 Self,
820 crate::wire::ControllerOpenExposedDirRequest,
821 > = unsafe {
822 ::fidl_next::CopyOptimization::enable_if(
823 true && <::fidl_next::ServerEnd<
824 ::fidl_next_fuchsia_io::Directory,
825 ::fidl_next::fuchsia::zx::Channel,
826 > as ::fidl_next::Encode<
827 ::fidl_next::ServerEnd<
828 ::fidl_next_fuchsia_io::Directory,
829 ::fidl_next::wire::fuchsia::Channel,
830 >,
831 ___E,
832 >>::COPY_OPTIMIZATION
833 .is_enabled(),
834 )
835 };
836
837 #[inline]
838 fn encode(
839 self,
840 encoder_: &mut ___E,
841 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerOpenExposedDirRequest>,
842 _: (),
843 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
844 ::fidl_next::munge! {
845 let crate::wire::ControllerOpenExposedDirRequest {
846 exposed_dir,
847
848 } = out_;
849 }
850
851 ::fidl_next::Encode::encode(self.exposed_dir, encoder_, exposed_dir, ())?;
852
853 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(exposed_dir.as_mut_ptr()) };
854
855 Ok(())
856 }
857 }
858
859 unsafe impl<___E>
860 ::fidl_next::EncodeOption<
861 ::fidl_next::wire::Box<'static, crate::wire::ControllerOpenExposedDirRequest>,
862 ___E,
863 > for ControllerOpenExposedDirRequest
864 where
865 ___E: ::fidl_next::Encoder + ?Sized,
866 ControllerOpenExposedDirRequest:
867 ::fidl_next::Encode<crate::wire::ControllerOpenExposedDirRequest, ___E>,
868 {
869 #[inline]
870 fn encode_option(
871 this: ::core::option::Option<Self>,
872 encoder: &mut ___E,
873 out: &mut ::core::mem::MaybeUninit<
874 ::fidl_next::wire::Box<'static, crate::wire::ControllerOpenExposedDirRequest>,
875 >,
876 _: (),
877 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
878 if let Some(inner) = this {
879 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
880 ::fidl_next::wire::Box::encode_present(out);
881 } else {
882 ::fidl_next::wire::Box::encode_absent(out);
883 }
884
885 Ok(())
886 }
887 }
888
889 impl ::fidl_next::FromWire<crate::wire::ControllerOpenExposedDirRequest>
890 for ControllerOpenExposedDirRequest
891 {
892 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
893 crate::wire::ControllerOpenExposedDirRequest,
894 Self,
895 > = unsafe {
896 ::fidl_next::CopyOptimization::enable_if(
897 true && <::fidl_next::ServerEnd<
898 ::fidl_next_fuchsia_io::Directory,
899 ::fidl_next::fuchsia::zx::Channel,
900 > as ::fidl_next::FromWire<
901 ::fidl_next::ServerEnd<
902 ::fidl_next_fuchsia_io::Directory,
903 ::fidl_next::wire::fuchsia::Channel,
904 >,
905 >>::COPY_OPTIMIZATION
906 .is_enabled(),
907 )
908 };
909
910 #[inline]
911 fn from_wire(wire: crate::wire::ControllerOpenExposedDirRequest) -> Self {
912 Self { exposed_dir: ::fidl_next::FromWire::from_wire(wire.exposed_dir) }
913 }
914 }
915
916 #[derive(Debug, Default, PartialEq)]
917 pub struct CreateChildArgs {
918 pub numbered_handles: ::core::option::Option<
919 ::std::vec::Vec<::fidl_next_fuchsia_process::natural::HandleInfo>,
920 >,
921
922 pub dynamic_offers: ::core::option::Option<
923 ::std::vec::Vec<::fidl_next_fuchsia_component_decl::natural::Offer>,
924 >,
925
926 pub controller: ::core::option::Option<
927 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::fuchsia::zx::Channel>,
928 >,
929
930 pub dictionary:
931 ::core::option::Option<::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef>,
932
933 pub additional_inputs: ::core::option::Option<::fidl_next::fuchsia::zx::EventPair>,
934 }
935
936 impl CreateChildArgs {
937 fn __max_ordinal(&self) -> usize {
938 if self.additional_inputs.is_some() {
939 return 5;
940 }
941
942 if self.dictionary.is_some() {
943 return 4;
944 }
945
946 if self.controller.is_some() {
947 return 3;
948 }
949
950 if self.dynamic_offers.is_some() {
951 return 2;
952 }
953
954 if self.numbered_handles.is_some() {
955 return 1;
956 }
957
958 0
959 }
960 }
961
962 unsafe impl<___E> ::fidl_next::Encode<crate::wire::CreateChildArgs<'static>, ___E>
963 for CreateChildArgs
964 where
965 ___E: ::fidl_next::Encoder + ?Sized,
966 ___E: ::fidl_next::fuchsia::HandleEncoder,
967 {
968 #[inline]
969 fn encode(
970 mut self,
971 encoder: &mut ___E,
972 out: &mut ::core::mem::MaybeUninit<crate::wire::CreateChildArgs<'static>>,
973 _: (),
974 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
975 ::fidl_next::munge!(let crate::wire::CreateChildArgs { table } = out);
976
977 let max_ord = self.__max_ordinal();
978
979 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
980 ::fidl_next::Wire::zero_padding(&mut out);
981
982 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
983 ::fidl_next::wire::Envelope,
984 >(encoder, max_ord);
985
986 for i in 1..=max_ord {
987 match i {
988 5 => {
989 if let Some(value) = self.additional_inputs.take() {
990 ::fidl_next::wire::Envelope::encode_value::<
991 ::fidl_next::wire::fuchsia::EventPair,
992 ___E,
993 >(
994 value, preallocated.encoder, &mut out, ()
995 )?;
996 } else {
997 ::fidl_next::wire::Envelope::encode_zero(&mut out)
998 }
999 }
1000
1001 4 => {
1002 if let Some(value) = self.dictionary.take() {
1003 ::fidl_next::wire::Envelope::encode_value::<
1004 ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
1005 ___E,
1006 >(
1007 value, preallocated.encoder, &mut out, ()
1008 )?;
1009 } else {
1010 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1011 }
1012 }
1013
1014 3 => {
1015 if let Some(value) = self.controller.take() {
1016 ::fidl_next::wire::Envelope::encode_value::<
1017 ::fidl_next::ServerEnd<
1018 crate::Controller,
1019 ::fidl_next::wire::fuchsia::Channel,
1020 >,
1021 ___E,
1022 >(
1023 value, preallocated.encoder, &mut out, ()
1024 )?;
1025 } else {
1026 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1027 }
1028 }
1029
1030 2 => {
1031 if let Some(value) = self.dynamic_offers.take() {
1032 ::fidl_next::wire::Envelope::encode_value::<
1033 ::fidl_next::wire::Vector<
1034 'static,
1035 ::fidl_next_fuchsia_component_decl::wire::Offer<'static>,
1036 >,
1037 ___E,
1038 >(
1039 value, preallocated.encoder, &mut out, (128, ())
1040 )?;
1041 } else {
1042 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1043 }
1044 }
1045
1046 1 => {
1047 if let Some(value) = self.numbered_handles.take() {
1048 ::fidl_next::wire::Envelope::encode_value::<
1049 ::fidl_next::wire::Vector<
1050 'static,
1051 ::fidl_next_fuchsia_process::wire::HandleInfo,
1052 >,
1053 ___E,
1054 >(
1055 value, preallocated.encoder, &mut out, (128, ())
1056 )?;
1057 } else {
1058 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1059 }
1060 }
1061
1062 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1063 }
1064 unsafe {
1065 preallocated.write_next(out.assume_init_ref());
1066 }
1067 }
1068
1069 ::fidl_next::wire::Table::encode_len(table, max_ord);
1070
1071 Ok(())
1072 }
1073 }
1074
1075 impl<'de> ::fidl_next::FromWire<crate::wire::CreateChildArgs<'de>> for CreateChildArgs {
1076 #[inline]
1077 fn from_wire(wire_: crate::wire::CreateChildArgs<'de>) -> Self {
1078 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1079
1080 let numbered_handles = wire_.table.get(1);
1081
1082 let dynamic_offers = wire_.table.get(2);
1083
1084 let controller = wire_.table.get(3);
1085
1086 let dictionary = wire_.table.get(4);
1087
1088 let additional_inputs = wire_.table.get(5);
1089
1090 Self {
1091
1092
1093 numbered_handles: numbered_handles.map(|envelope| ::fidl_next::FromWire::from_wire(
1094 unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>>() }
1095 )),
1096
1097
1098 dynamic_offers: dynamic_offers.map(|envelope| ::fidl_next::FromWire::from_wire(
1099 unsafe { envelope.read_unchecked::<::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_component_decl::wire::Offer<'de>>>() }
1100 )),
1101
1102
1103 controller: controller.map(|envelope| ::fidl_next::FromWire::from_wire(
1104 unsafe { envelope.read_unchecked::<::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>>() }
1105 )),
1106
1107
1108 dictionary: dictionary.map(|envelope| ::fidl_next::FromWire::from_wire(
1109 unsafe { envelope.read_unchecked::<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>() }
1110 )),
1111
1112
1113 additional_inputs: additional_inputs.map(|envelope| ::fidl_next::FromWire::from_wire(
1114 unsafe { envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>() }
1115 )),
1116
1117 }
1118 }
1119 }
1120
1121 #[doc = " Payload for DebugStarted events.\n"]
1122 #[derive(Debug, Default, PartialEq)]
1123 pub struct DebugStartedPayload {
1124 pub runtime_dir: ::core::option::Option<
1125 ::fidl_next::ClientEnd<
1126 ::fidl_next_fuchsia_io::Directory,
1127 ::fidl_next::fuchsia::zx::Channel,
1128 >,
1129 >,
1130
1131 pub break_on_start: ::core::option::Option<::fidl_next::fuchsia::zx::EventPair>,
1132 }
1133
1134 impl DebugStartedPayload {
1135 fn __max_ordinal(&self) -> usize {
1136 if self.break_on_start.is_some() {
1137 return 2;
1138 }
1139
1140 if self.runtime_dir.is_some() {
1141 return 1;
1142 }
1143
1144 0
1145 }
1146 }
1147
1148 unsafe impl<___E> ::fidl_next::Encode<crate::wire::DebugStartedPayload<'static>, ___E>
1149 for DebugStartedPayload
1150 where
1151 ___E: ::fidl_next::Encoder + ?Sized,
1152 ___E: ::fidl_next::fuchsia::HandleEncoder,
1153 {
1154 #[inline]
1155 fn encode(
1156 mut self,
1157 encoder: &mut ___E,
1158 out: &mut ::core::mem::MaybeUninit<crate::wire::DebugStartedPayload<'static>>,
1159 _: (),
1160 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1161 ::fidl_next::munge!(let crate::wire::DebugStartedPayload { table } = out);
1162
1163 let max_ord = self.__max_ordinal();
1164
1165 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1166 ::fidl_next::Wire::zero_padding(&mut out);
1167
1168 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1169 ::fidl_next::wire::Envelope,
1170 >(encoder, max_ord);
1171
1172 for i in 1..=max_ord {
1173 match i {
1174 2 => {
1175 if let Some(value) = self.break_on_start.take() {
1176 ::fidl_next::wire::Envelope::encode_value::<
1177 ::fidl_next::wire::fuchsia::EventPair,
1178 ___E,
1179 >(
1180 value, preallocated.encoder, &mut out, ()
1181 )?;
1182 } else {
1183 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1184 }
1185 }
1186
1187 1 => {
1188 if let Some(value) = self.runtime_dir.take() {
1189 ::fidl_next::wire::Envelope::encode_value::<
1190 ::fidl_next::ClientEnd<
1191 ::fidl_next_fuchsia_io::Directory,
1192 ::fidl_next::wire::fuchsia::Channel,
1193 >,
1194 ___E,
1195 >(
1196 value, preallocated.encoder, &mut out, ()
1197 )?;
1198 } else {
1199 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1200 }
1201 }
1202
1203 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1204 }
1205 unsafe {
1206 preallocated.write_next(out.assume_init_ref());
1207 }
1208 }
1209
1210 ::fidl_next::wire::Table::encode_len(table, max_ord);
1211
1212 Ok(())
1213 }
1214 }
1215
1216 impl<'de> ::fidl_next::FromWire<crate::wire::DebugStartedPayload<'de>> for DebugStartedPayload {
1217 #[inline]
1218 fn from_wire(wire_: crate::wire::DebugStartedPayload<'de>) -> Self {
1219 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1220
1221 let runtime_dir = wire_.table.get(1);
1222
1223 let break_on_start = wire_.table.get(2);
1224
1225 Self {
1226 runtime_dir: runtime_dir.map(|envelope| {
1227 ::fidl_next::FromWire::from_wire(unsafe {
1228 envelope.read_unchecked::<::fidl_next::ClientEnd<
1229 ::fidl_next_fuchsia_io::Directory,
1230 ::fidl_next::wire::fuchsia::Channel,
1231 >>()
1232 })
1233 }),
1234
1235 break_on_start: break_on_start.map(|envelope| {
1236 ::fidl_next::FromWire::from_wire(unsafe {
1237 envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>()
1238 })
1239 }),
1240 }
1241 }
1242 }
1243
1244 #[doc = " Encapsulates additional data/protocols for some event types.\n"]
1245 #[derive(Debug, PartialEq)]
1246 pub enum EventPayload {
1247 CapabilityRequested(crate::natural::CapabilityRequestedPayload),
1248
1249 Purged(crate::natural::PurgedPayload),
1250
1251 Discovered(crate::natural::DiscoveredPayload),
1252
1253 Destroyed(crate::natural::DestroyedPayload),
1254
1255 Resolved(crate::natural::ResolvedPayload),
1256
1257 Started(crate::natural::StartedPayload),
1258
1259 Stopped(crate::natural::StoppedPayload),
1260
1261 DebugStarted(crate::natural::DebugStartedPayload),
1262
1263 Unresolved(crate::natural::UnresolvedPayload),
1264
1265 UnknownOrdinal_(u64),
1266 }
1267
1268 impl EventPayload {
1269 pub fn is_unknown(&self) -> bool {
1270 #[allow(unreachable_patterns)]
1271 match self {
1272 Self::UnknownOrdinal_(_) => true,
1273 _ => false,
1274 }
1275 }
1276 }
1277
1278 unsafe impl<___E> ::fidl_next::Encode<crate::wire::EventPayload<'static>, ___E> for EventPayload
1279 where
1280 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1281 ___E: ::fidl_next::Encoder,
1282 ___E: ::fidl_next::fuchsia::HandleEncoder,
1283 {
1284 #[inline]
1285 fn encode(
1286 self,
1287 encoder: &mut ___E,
1288 out: &mut ::core::mem::MaybeUninit<crate::wire::EventPayload<'static>>,
1289 _: (),
1290 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1291 ::fidl_next::munge!(let crate::wire::EventPayload { raw, _phantom: _ } = out);
1292
1293 match self {
1294 Self::CapabilityRequested(value) => ::fidl_next::wire::Union::encode_as::<
1295 ___E,
1296 crate::wire::CapabilityRequestedPayload<'static>,
1297 >(value, 1, encoder, raw, ())?,
1298
1299 Self::Purged(value) => ::fidl_next::wire::Union::encode_as::<
1300 ___E,
1301 crate::wire::PurgedPayload<'static>,
1302 >(value, 2, encoder, raw, ())?,
1303
1304 Self::Discovered(value) => ::fidl_next::wire::Union::encode_as::<
1305 ___E,
1306 crate::wire::DiscoveredPayload<'static>,
1307 >(value, 4, encoder, raw, ())?,
1308
1309 Self::Destroyed(value) => ::fidl_next::wire::Union::encode_as::<
1310 ___E,
1311 crate::wire::DestroyedPayload<'static>,
1312 >(value, 5, encoder, raw, ())?,
1313
1314 Self::Resolved(value) => ::fidl_next::wire::Union::encode_as::<
1315 ___E,
1316 crate::wire::ResolvedPayload<'static>,
1317 >(value, 6, encoder, raw, ())?,
1318
1319 Self::Started(value) => ::fidl_next::wire::Union::encode_as::<
1320 ___E,
1321 crate::wire::StartedPayload<'static>,
1322 >(value, 7, encoder, raw, ())?,
1323
1324 Self::Stopped(value) => ::fidl_next::wire::Union::encode_as::<
1325 ___E,
1326 crate::wire::StoppedPayload<'static>,
1327 >(value, 8, encoder, raw, ())?,
1328
1329 Self::DebugStarted(value) => ::fidl_next::wire::Union::encode_as::<
1330 ___E,
1331 crate::wire::DebugStartedPayload<'static>,
1332 >(value, 9, encoder, raw, ())?,
1333
1334 Self::Unresolved(value) => ::fidl_next::wire::Union::encode_as::<
1335 ___E,
1336 crate::wire::UnresolvedPayload<'static>,
1337 >(value, 10, encoder, raw, ())?,
1338
1339 Self::UnknownOrdinal_(ordinal) => {
1340 return Err(::fidl_next::EncodeError::UnknownUnionOrdinal(ordinal as usize));
1341 }
1342 }
1343
1344 Ok(())
1345 }
1346 }
1347
1348 unsafe impl<___E> ::fidl_next::EncodeOption<crate::wire_optional::EventPayload<'static>, ___E>
1349 for EventPayload
1350 where
1351 ___E: ?Sized,
1352 EventPayload: ::fidl_next::Encode<crate::wire::EventPayload<'static>, ___E>,
1353 {
1354 #[inline]
1355 fn encode_option(
1356 this: ::core::option::Option<Self>,
1357 encoder: &mut ___E,
1358 out: &mut ::core::mem::MaybeUninit<crate::wire_optional::EventPayload<'static>>,
1359 _: (),
1360 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1361 ::fidl_next::munge!(let crate::wire_optional::EventPayload { raw, _phantom: _ } = &mut *out);
1362
1363 if let Some(inner) = this {
1364 let value_out = unsafe { &mut *out.as_mut_ptr().cast() };
1365 ::fidl_next::Encode::encode(inner, encoder, value_out, ())?;
1366 } else {
1367 ::fidl_next::wire::Union::encode_absent(raw);
1368 }
1369
1370 Ok(())
1371 }
1372 }
1373
1374 impl<'de> ::fidl_next::FromWire<crate::wire::EventPayload<'de>> for EventPayload {
1375 #[inline]
1376 fn from_wire(wire: crate::wire::EventPayload<'de>) -> Self {
1377 let wire = ::core::mem::ManuallyDrop::new(wire);
1378 match wire.raw.ordinal() {
1379 1 => Self::CapabilityRequested(::fidl_next::FromWire::from_wire(unsafe {
1380 wire.raw.get().read_unchecked::<crate::wire::CapabilityRequestedPayload<'de>>()
1381 })),
1382
1383 2 => Self::Purged(::fidl_next::FromWire::from_wire(unsafe {
1384 wire.raw.get().read_unchecked::<crate::wire::PurgedPayload<'de>>()
1385 })),
1386
1387 4 => Self::Discovered(::fidl_next::FromWire::from_wire(unsafe {
1388 wire.raw.get().read_unchecked::<crate::wire::DiscoveredPayload<'de>>()
1389 })),
1390
1391 5 => Self::Destroyed(::fidl_next::FromWire::from_wire(unsafe {
1392 wire.raw.get().read_unchecked::<crate::wire::DestroyedPayload<'de>>()
1393 })),
1394
1395 6 => Self::Resolved(::fidl_next::FromWire::from_wire(unsafe {
1396 wire.raw.get().read_unchecked::<crate::wire::ResolvedPayload<'de>>()
1397 })),
1398
1399 7 => Self::Started(::fidl_next::FromWire::from_wire(unsafe {
1400 wire.raw.get().read_unchecked::<crate::wire::StartedPayload<'de>>()
1401 })),
1402
1403 8 => Self::Stopped(::fidl_next::FromWire::from_wire(unsafe {
1404 wire.raw.get().read_unchecked::<crate::wire::StoppedPayload<'de>>()
1405 })),
1406
1407 9 => Self::DebugStarted(::fidl_next::FromWire::from_wire(unsafe {
1408 wire.raw.get().read_unchecked::<crate::wire::DebugStartedPayload<'de>>()
1409 })),
1410
1411 10 => Self::Unresolved(::fidl_next::FromWire::from_wire(unsafe {
1412 wire.raw.get().read_unchecked::<crate::wire::UnresolvedPayload<'de>>()
1413 })),
1414
1415 ord => return Self::UnknownOrdinal_(ord as u64),
1416 }
1417 }
1418 }
1419
1420 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::EventPayload<'de>> for EventPayload {
1421 #[inline]
1422 fn from_wire_option(
1423 wire: crate::wire_optional::EventPayload<'de>,
1424 ) -> ::core::option::Option<Self> {
1425 if let Some(inner) = wire.into_option() {
1426 Some(::fidl_next::FromWire::from_wire(inner))
1427 } else {
1428 None
1429 }
1430 }
1431 }
1432
1433 impl<'de> ::fidl_next::FromWireOption<crate::wire_optional::EventPayload<'de>>
1434 for Box<EventPayload>
1435 {
1436 #[inline]
1437 fn from_wire_option(
1438 wire: crate::wire_optional::EventPayload<'de>,
1439 ) -> ::core::option::Option<Self> {
1440 <
1441 EventPayload as ::fidl_next::FromWireOption<crate::wire_optional::EventPayload<'de>>
1442 >::from_wire_option(wire).map(Box::new)
1443 }
1444 }
1445
1446 #[doc = " Contains all information about a single event\n"]
1447 #[derive(Debug, Default, PartialEq)]
1448 pub struct Event {
1449 pub header: ::core::option::Option<crate::natural::EventHeader>,
1450
1451 pub payload: ::core::option::Option<crate::natural::EventPayload>,
1452 }
1453
1454 impl Event {
1455 fn __max_ordinal(&self) -> usize {
1456 if self.payload.is_some() {
1457 return 2;
1458 }
1459
1460 if self.header.is_some() {
1461 return 1;
1462 }
1463
1464 0
1465 }
1466 }
1467
1468 unsafe impl<___E> ::fidl_next::Encode<crate::wire::Event<'static>, ___E> for Event
1469 where
1470 ___E: ::fidl_next::Encoder + ?Sized,
1471 ___E: ::fidl_next::fuchsia::HandleEncoder,
1472 {
1473 #[inline]
1474 fn encode(
1475 mut self,
1476 encoder: &mut ___E,
1477 out: &mut ::core::mem::MaybeUninit<crate::wire::Event<'static>>,
1478 _: (),
1479 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1480 ::fidl_next::munge!(let crate::wire::Event { table } = out);
1481
1482 let max_ord = self.__max_ordinal();
1483
1484 let mut out = ::core::mem::MaybeUninit::<::fidl_next::wire::Envelope>::uninit();
1485 ::fidl_next::Wire::zero_padding(&mut out);
1486
1487 let mut preallocated = ::fidl_next::EncoderExt::preallocate::<
1488 ::fidl_next::wire::Envelope,
1489 >(encoder, max_ord);
1490
1491 for i in 1..=max_ord {
1492 match i {
1493 2 => {
1494 if let Some(value) = self.payload.take() {
1495 ::fidl_next::wire::Envelope::encode_value::<
1496 crate::wire::EventPayload<'static>,
1497 ___E,
1498 >(
1499 value, preallocated.encoder, &mut out, ()
1500 )?;
1501 } else {
1502 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1503 }
1504 }
1505
1506 1 => {
1507 if let Some(value) = self.header.take() {
1508 ::fidl_next::wire::Envelope::encode_value::<
1509 crate::wire::EventHeader<'static>,
1510 ___E,
1511 >(
1512 value, preallocated.encoder, &mut out, ()
1513 )?;
1514 } else {
1515 ::fidl_next::wire::Envelope::encode_zero(&mut out)
1516 }
1517 }
1518
1519 _ => ::fidl_next::wire::Envelope::encode_zero(&mut out),
1520 }
1521 unsafe {
1522 preallocated.write_next(out.assume_init_ref());
1523 }
1524 }
1525
1526 ::fidl_next::wire::Table::encode_len(table, max_ord);
1527
1528 Ok(())
1529 }
1530 }
1531
1532 impl<'de> ::fidl_next::FromWire<crate::wire::Event<'de>> for Event {
1533 #[inline]
1534 fn from_wire(wire_: crate::wire::Event<'de>) -> Self {
1535 let wire_ = ::core::mem::ManuallyDrop::new(wire_);
1536
1537 let header = wire_.table.get(1);
1538
1539 let payload = wire_.table.get(2);
1540
1541 Self {
1542 header: header.map(|envelope| {
1543 ::fidl_next::FromWire::from_wire(unsafe {
1544 envelope.read_unchecked::<crate::wire::EventHeader<'de>>()
1545 })
1546 }),
1547
1548 payload: payload.map(|envelope| {
1549 ::fidl_next::FromWire::from_wire(unsafe {
1550 envelope.read_unchecked::<crate::wire::EventPayload<'de>>()
1551 })
1552 }),
1553 }
1554 }
1555 }
1556
1557 #[derive(Debug, PartialEq)]
1558 pub struct EventStreamGetNextResponse {
1559 pub events: ::std::vec::Vec<crate::natural::Event>,
1560 }
1561
1562 unsafe impl<___E> ::fidl_next::Encode<crate::wire::EventStreamGetNextResponse<'static>, ___E>
1563 for EventStreamGetNextResponse
1564 where
1565 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1566 ___E: ::fidl_next::Encoder,
1567 ___E: ::fidl_next::fuchsia::HandleEncoder,
1568 {
1569 #[inline]
1570 fn encode(
1571 self,
1572 encoder_: &mut ___E,
1573 out_: &mut ::core::mem::MaybeUninit<crate::wire::EventStreamGetNextResponse<'static>>,
1574 _: (),
1575 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1576 ::fidl_next::munge! {
1577 let crate::wire::EventStreamGetNextResponse {
1578 events,
1579
1580 } = out_;
1581 }
1582
1583 ::fidl_next::Encode::encode(self.events, encoder_, events, (4294967295, ()))?;
1584
1585 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(events.as_mut_ptr()) };
1586 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
1587
1588 Ok(())
1589 }
1590 }
1591
1592 unsafe impl<___E>
1593 ::fidl_next::EncodeOption<
1594 ::fidl_next::wire::Box<'static, crate::wire::EventStreamGetNextResponse<'static>>,
1595 ___E,
1596 > for EventStreamGetNextResponse
1597 where
1598 ___E: ::fidl_next::Encoder + ?Sized,
1599 EventStreamGetNextResponse:
1600 ::fidl_next::Encode<crate::wire::EventStreamGetNextResponse<'static>, ___E>,
1601 {
1602 #[inline]
1603 fn encode_option(
1604 this: ::core::option::Option<Self>,
1605 encoder: &mut ___E,
1606 out: &mut ::core::mem::MaybeUninit<
1607 ::fidl_next::wire::Box<'static, crate::wire::EventStreamGetNextResponse<'static>>,
1608 >,
1609 _: (),
1610 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1611 if let Some(inner) = this {
1612 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1613 ::fidl_next::wire::Box::encode_present(out);
1614 } else {
1615 ::fidl_next::wire::Box::encode_absent(out);
1616 }
1617
1618 Ok(())
1619 }
1620 }
1621
1622 impl<'de> ::fidl_next::FromWire<crate::wire::EventStreamGetNextResponse<'de>>
1623 for EventStreamGetNextResponse
1624 {
1625 #[inline]
1626 fn from_wire(wire: crate::wire::EventStreamGetNextResponse<'de>) -> Self {
1627 Self { events: ::fidl_next::FromWire::from_wire(wire.events) }
1628 }
1629 }
1630
1631 #[derive(Debug, PartialEq)]
1632 #[repr(C)]
1633 pub struct IntrospectorGetMonikerRequest {
1634 pub component_instance: ::fidl_next::fuchsia::zx::Event,
1635 }
1636
1637 unsafe impl<___E> ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerRequest, ___E>
1638 for IntrospectorGetMonikerRequest
1639 where
1640 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1641 ___E: ::fidl_next::fuchsia::HandleEncoder,
1642 {
1643 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1644 Self,
1645 crate::wire::IntrospectorGetMonikerRequest,
1646 > = unsafe {
1647 ::fidl_next::CopyOptimization::enable_if(
1648 true && <::fidl_next::fuchsia::zx::Event as ::fidl_next::Encode<
1649 ::fidl_next::wire::fuchsia::Event,
1650 ___E,
1651 >>::COPY_OPTIMIZATION
1652 .is_enabled(),
1653 )
1654 };
1655
1656 #[inline]
1657 fn encode(
1658 self,
1659 encoder_: &mut ___E,
1660 out_: &mut ::core::mem::MaybeUninit<crate::wire::IntrospectorGetMonikerRequest>,
1661 _: (),
1662 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1663 ::fidl_next::munge! {
1664 let crate::wire::IntrospectorGetMonikerRequest {
1665 component_instance,
1666
1667 } = out_;
1668 }
1669
1670 ::fidl_next::Encode::encode(self.component_instance, encoder_, component_instance, ())?;
1671
1672 let mut _field =
1673 unsafe { ::fidl_next::Slot::new_unchecked(component_instance.as_mut_ptr()) };
1674
1675 Ok(())
1676 }
1677 }
1678
1679 unsafe impl<___E>
1680 ::fidl_next::EncodeOption<
1681 ::fidl_next::wire::Box<'static, crate::wire::IntrospectorGetMonikerRequest>,
1682 ___E,
1683 > for IntrospectorGetMonikerRequest
1684 where
1685 ___E: ::fidl_next::Encoder + ?Sized,
1686 IntrospectorGetMonikerRequest:
1687 ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerRequest, ___E>,
1688 {
1689 #[inline]
1690 fn encode_option(
1691 this: ::core::option::Option<Self>,
1692 encoder: &mut ___E,
1693 out: &mut ::core::mem::MaybeUninit<
1694 ::fidl_next::wire::Box<'static, crate::wire::IntrospectorGetMonikerRequest>,
1695 >,
1696 _: (),
1697 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1698 if let Some(inner) = this {
1699 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1700 ::fidl_next::wire::Box::encode_present(out);
1701 } else {
1702 ::fidl_next::wire::Box::encode_absent(out);
1703 }
1704
1705 Ok(())
1706 }
1707 }
1708
1709 impl ::fidl_next::FromWire<crate::wire::IntrospectorGetMonikerRequest>
1710 for IntrospectorGetMonikerRequest
1711 {
1712 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
1713 crate::wire::IntrospectorGetMonikerRequest,
1714 Self,
1715 > = unsafe {
1716 ::fidl_next::CopyOptimization::enable_if(
1717 true && <::fidl_next::fuchsia::zx::Event as ::fidl_next::FromWire<
1718 ::fidl_next::wire::fuchsia::Event,
1719 >>::COPY_OPTIMIZATION
1720 .is_enabled(),
1721 )
1722 };
1723
1724 #[inline]
1725 fn from_wire(wire: crate::wire::IntrospectorGetMonikerRequest) -> Self {
1726 Self { component_instance: ::fidl_next::FromWire::from_wire(wire.component_instance) }
1727 }
1728 }
1729
1730 #[derive(Debug, PartialEq)]
1731 pub struct NamespaceInputEntry {
1732 pub path: ::std::string::String,
1733
1734 pub dictionary: ::fidl_next::ClientEnd<
1735 ::fidl_next_fuchsia_component_sandbox::Dictionary,
1736 ::fidl_next::fuchsia::zx::Channel,
1737 >,
1738 }
1739
1740 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceInputEntry<'static>, ___E>
1741 for NamespaceInputEntry
1742 where
1743 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1744 ___E: ::fidl_next::Encoder,
1745 ___E: ::fidl_next::fuchsia::HandleEncoder,
1746 {
1747 #[inline]
1748 fn encode(
1749 self,
1750 encoder_: &mut ___E,
1751 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceInputEntry<'static>>,
1752 _: (),
1753 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1754 ::fidl_next::munge! {
1755 let crate::wire::NamespaceInputEntry {
1756 path,
1757 dictionary,
1758
1759 } = out_;
1760 }
1761
1762 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
1763
1764 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(path.as_mut_ptr()) };
1765 ::fidl_next::Constrained::validate(_field, 4095)?;
1766
1767 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
1768
1769 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dictionary.as_mut_ptr()) };
1770
1771 Ok(())
1772 }
1773 }
1774
1775 unsafe impl<___E>
1776 ::fidl_next::EncodeOption<
1777 ::fidl_next::wire::Box<'static, crate::wire::NamespaceInputEntry<'static>>,
1778 ___E,
1779 > for NamespaceInputEntry
1780 where
1781 ___E: ::fidl_next::Encoder + ?Sized,
1782 NamespaceInputEntry: ::fidl_next::Encode<crate::wire::NamespaceInputEntry<'static>, ___E>,
1783 {
1784 #[inline]
1785 fn encode_option(
1786 this: ::core::option::Option<Self>,
1787 encoder: &mut ___E,
1788 out: &mut ::core::mem::MaybeUninit<
1789 ::fidl_next::wire::Box<'static, crate::wire::NamespaceInputEntry<'static>>,
1790 >,
1791 _: (),
1792 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1793 if let Some(inner) = this {
1794 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1795 ::fidl_next::wire::Box::encode_present(out);
1796 } else {
1797 ::fidl_next::wire::Box::encode_absent(out);
1798 }
1799
1800 Ok(())
1801 }
1802 }
1803
1804 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceInputEntry<'de>> for NamespaceInputEntry {
1805 #[inline]
1806 fn from_wire(wire: crate::wire::NamespaceInputEntry<'de>) -> Self {
1807 Self {
1808 path: ::fidl_next::FromWire::from_wire(wire.path),
1809
1810 dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary),
1811 }
1812 }
1813 }
1814
1815 #[derive(Debug, PartialEq)]
1816 pub struct NamespaceCreateRequest {
1817 pub entries: ::std::vec::Vec<crate::natural::NamespaceInputEntry>,
1818 }
1819
1820 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceCreateRequest<'static>, ___E>
1821 for NamespaceCreateRequest
1822 where
1823 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1824 ___E: ::fidl_next::Encoder,
1825 ___E: ::fidl_next::fuchsia::HandleEncoder,
1826 {
1827 #[inline]
1828 fn encode(
1829 self,
1830 encoder_: &mut ___E,
1831 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreateRequest<'static>>,
1832 _: (),
1833 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1834 ::fidl_next::munge! {
1835 let crate::wire::NamespaceCreateRequest {
1836 entries,
1837
1838 } = out_;
1839 }
1840
1841 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
1842
1843 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(entries.as_mut_ptr()) };
1844 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
1845
1846 Ok(())
1847 }
1848 }
1849
1850 unsafe impl<___E>
1851 ::fidl_next::EncodeOption<
1852 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreateRequest<'static>>,
1853 ___E,
1854 > for NamespaceCreateRequest
1855 where
1856 ___E: ::fidl_next::Encoder + ?Sized,
1857 NamespaceCreateRequest:
1858 ::fidl_next::Encode<crate::wire::NamespaceCreateRequest<'static>, ___E>,
1859 {
1860 #[inline]
1861 fn encode_option(
1862 this: ::core::option::Option<Self>,
1863 encoder: &mut ___E,
1864 out: &mut ::core::mem::MaybeUninit<
1865 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreateRequest<'static>>,
1866 >,
1867 _: (),
1868 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1869 if let Some(inner) = this {
1870 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1871 ::fidl_next::wire::Box::encode_present(out);
1872 } else {
1873 ::fidl_next::wire::Box::encode_absent(out);
1874 }
1875
1876 Ok(())
1877 }
1878 }
1879
1880 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceCreateRequest<'de>>
1881 for NamespaceCreateRequest
1882 {
1883 #[inline]
1884 fn from_wire(wire: crate::wire::NamespaceCreateRequest<'de>) -> Self {
1885 Self { entries: ::fidl_next::FromWire::from_wire(wire.entries) }
1886 }
1887 }
1888
1889 #[derive(Debug, PartialEq)]
1890 pub struct NamespaceInputEntry2 {
1891 pub path: ::std::string::String,
1892
1893 pub capability: ::fidl_next::fuchsia::zx::EventPair,
1894 }
1895
1896 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceInputEntry2<'static>, ___E>
1897 for NamespaceInputEntry2
1898 where
1899 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1900 ___E: ::fidl_next::Encoder,
1901 ___E: ::fidl_next::fuchsia::HandleEncoder,
1902 {
1903 #[inline]
1904 fn encode(
1905 self,
1906 encoder_: &mut ___E,
1907 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceInputEntry2<'static>>,
1908 _: (),
1909 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1910 ::fidl_next::munge! {
1911 let crate::wire::NamespaceInputEntry2 {
1912 path,
1913 capability,
1914
1915 } = out_;
1916 }
1917
1918 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
1919
1920 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(path.as_mut_ptr()) };
1921 ::fidl_next::Constrained::validate(_field, 4095)?;
1922
1923 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
1924
1925 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(capability.as_mut_ptr()) };
1926
1927 Ok(())
1928 }
1929 }
1930
1931 unsafe impl<___E>
1932 ::fidl_next::EncodeOption<
1933 ::fidl_next::wire::Box<'static, crate::wire::NamespaceInputEntry2<'static>>,
1934 ___E,
1935 > for NamespaceInputEntry2
1936 where
1937 ___E: ::fidl_next::Encoder + ?Sized,
1938 NamespaceInputEntry2: ::fidl_next::Encode<crate::wire::NamespaceInputEntry2<'static>, ___E>,
1939 {
1940 #[inline]
1941 fn encode_option(
1942 this: ::core::option::Option<Self>,
1943 encoder: &mut ___E,
1944 out: &mut ::core::mem::MaybeUninit<
1945 ::fidl_next::wire::Box<'static, crate::wire::NamespaceInputEntry2<'static>>,
1946 >,
1947 _: (),
1948 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1949 if let Some(inner) = this {
1950 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
1951 ::fidl_next::wire::Box::encode_present(out);
1952 } else {
1953 ::fidl_next::wire::Box::encode_absent(out);
1954 }
1955
1956 Ok(())
1957 }
1958 }
1959
1960 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceInputEntry2<'de>> for NamespaceInputEntry2 {
1961 #[inline]
1962 fn from_wire(wire: crate::wire::NamespaceInputEntry2<'de>) -> Self {
1963 Self {
1964 path: ::fidl_next::FromWire::from_wire(wire.path),
1965
1966 capability: ::fidl_next::FromWire::from_wire(wire.capability),
1967 }
1968 }
1969 }
1970
1971 #[derive(Debug, PartialEq)]
1972 pub struct NamespaceCreate2Request {
1973 pub entries: ::std::vec::Vec<crate::natural::NamespaceInputEntry2>,
1974 }
1975
1976 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceCreate2Request<'static>, ___E>
1977 for NamespaceCreate2Request
1978 where
1979 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
1980 ___E: ::fidl_next::Encoder,
1981 ___E: ::fidl_next::fuchsia::HandleEncoder,
1982 {
1983 #[inline]
1984 fn encode(
1985 self,
1986 encoder_: &mut ___E,
1987 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreate2Request<'static>>,
1988 _: (),
1989 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
1990 ::fidl_next::munge! {
1991 let crate::wire::NamespaceCreate2Request {
1992 entries,
1993
1994 } = out_;
1995 }
1996
1997 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
1998
1999 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(entries.as_mut_ptr()) };
2000 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
2001
2002 Ok(())
2003 }
2004 }
2005
2006 unsafe impl<___E>
2007 ::fidl_next::EncodeOption<
2008 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreate2Request<'static>>,
2009 ___E,
2010 > for NamespaceCreate2Request
2011 where
2012 ___E: ::fidl_next::Encoder + ?Sized,
2013 NamespaceCreate2Request:
2014 ::fidl_next::Encode<crate::wire::NamespaceCreate2Request<'static>, ___E>,
2015 {
2016 #[inline]
2017 fn encode_option(
2018 this: ::core::option::Option<Self>,
2019 encoder: &mut ___E,
2020 out: &mut ::core::mem::MaybeUninit<
2021 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreate2Request<'static>>,
2022 >,
2023 _: (),
2024 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2025 if let Some(inner) = this {
2026 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2027 ::fidl_next::wire::Box::encode_present(out);
2028 } else {
2029 ::fidl_next::wire::Box::encode_absent(out);
2030 }
2031
2032 Ok(())
2033 }
2034 }
2035
2036 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceCreate2Request<'de>>
2037 for NamespaceCreate2Request
2038 {
2039 #[inline]
2040 fn from_wire(wire: crate::wire::NamespaceCreate2Request<'de>) -> Self {
2041 Self { entries: ::fidl_next::FromWire::from_wire(wire.entries) }
2042 }
2043 }
2044
2045 #[derive(Debug, PartialEq)]
2046 pub struct NamespaceCreateResponse {
2047 pub entries: ::std::vec::Vec<crate::natural::NamespaceEntry>,
2048 }
2049
2050 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceCreateResponse<'static>, ___E>
2051 for NamespaceCreateResponse
2052 where
2053 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2054 ___E: ::fidl_next::Encoder,
2055 ___E: ::fidl_next::fuchsia::HandleEncoder,
2056 {
2057 #[inline]
2058 fn encode(
2059 self,
2060 encoder_: &mut ___E,
2061 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreateResponse<'static>>,
2062 _: (),
2063 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2064 ::fidl_next::munge! {
2065 let crate::wire::NamespaceCreateResponse {
2066 entries,
2067
2068 } = out_;
2069 }
2070
2071 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
2072
2073 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(entries.as_mut_ptr()) };
2074 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
2075
2076 Ok(())
2077 }
2078 }
2079
2080 unsafe impl<___E>
2081 ::fidl_next::EncodeOption<
2082 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreateResponse<'static>>,
2083 ___E,
2084 > for NamespaceCreateResponse
2085 where
2086 ___E: ::fidl_next::Encoder + ?Sized,
2087 NamespaceCreateResponse:
2088 ::fidl_next::Encode<crate::wire::NamespaceCreateResponse<'static>, ___E>,
2089 {
2090 #[inline]
2091 fn encode_option(
2092 this: ::core::option::Option<Self>,
2093 encoder: &mut ___E,
2094 out: &mut ::core::mem::MaybeUninit<
2095 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreateResponse<'static>>,
2096 >,
2097 _: (),
2098 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2099 if let Some(inner) = this {
2100 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2101 ::fidl_next::wire::Box::encode_present(out);
2102 } else {
2103 ::fidl_next::wire::Box::encode_absent(out);
2104 }
2105
2106 Ok(())
2107 }
2108 }
2109
2110 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceCreateResponse<'de>>
2111 for NamespaceCreateResponse
2112 {
2113 #[inline]
2114 fn from_wire(wire: crate::wire::NamespaceCreateResponse<'de>) -> Self {
2115 Self { entries: ::fidl_next::FromWire::from_wire(wire.entries) }
2116 }
2117 }
2118
2119 #[derive(Debug, PartialEq)]
2120 pub struct NamespaceCreate2Response {
2121 pub entries: ::std::vec::Vec<crate::natural::NamespaceEntry>,
2122 }
2123
2124 unsafe impl<___E> ::fidl_next::Encode<crate::wire::NamespaceCreate2Response<'static>, ___E>
2125 for NamespaceCreate2Response
2126 where
2127 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2128 ___E: ::fidl_next::Encoder,
2129 ___E: ::fidl_next::fuchsia::HandleEncoder,
2130 {
2131 #[inline]
2132 fn encode(
2133 self,
2134 encoder_: &mut ___E,
2135 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreate2Response<'static>>,
2136 _: (),
2137 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2138 ::fidl_next::munge! {
2139 let crate::wire::NamespaceCreate2Response {
2140 entries,
2141
2142 } = out_;
2143 }
2144
2145 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
2146
2147 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(entries.as_mut_ptr()) };
2148 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
2149
2150 Ok(())
2151 }
2152 }
2153
2154 unsafe impl<___E>
2155 ::fidl_next::EncodeOption<
2156 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreate2Response<'static>>,
2157 ___E,
2158 > for NamespaceCreate2Response
2159 where
2160 ___E: ::fidl_next::Encoder + ?Sized,
2161 NamespaceCreate2Response:
2162 ::fidl_next::Encode<crate::wire::NamespaceCreate2Response<'static>, ___E>,
2163 {
2164 #[inline]
2165 fn encode_option(
2166 this: ::core::option::Option<Self>,
2167 encoder: &mut ___E,
2168 out: &mut ::core::mem::MaybeUninit<
2169 ::fidl_next::wire::Box<'static, crate::wire::NamespaceCreate2Response<'static>>,
2170 >,
2171 _: (),
2172 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2173 if let Some(inner) = this {
2174 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2175 ::fidl_next::wire::Box::encode_present(out);
2176 } else {
2177 ::fidl_next::wire::Box::encode_absent(out);
2178 }
2179
2180 Ok(())
2181 }
2182 }
2183
2184 impl<'de> ::fidl_next::FromWire<crate::wire::NamespaceCreate2Response<'de>>
2185 for NamespaceCreate2Response
2186 {
2187 #[inline]
2188 fn from_wire(wire: crate::wire::NamespaceCreate2Response<'de>) -> Self {
2189 Self { entries: ::fidl_next::FromWire::from_wire(wire.entries) }
2190 }
2191 }
2192
2193 #[derive(Debug, PartialEq)]
2194 pub struct RealmListChildrenRequest {
2195 pub collection: ::fidl_next_fuchsia_component_decl::natural::CollectionRef,
2196
2197 pub iter: ::fidl_next::ServerEnd<crate::ChildIterator, ::fidl_next::fuchsia::zx::Channel>,
2198 }
2199
2200 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmListChildrenRequest<'static>, ___E>
2201 for RealmListChildrenRequest
2202 where
2203 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2204 ___E: ::fidl_next::Encoder,
2205 ___E: ::fidl_next::fuchsia::HandleEncoder,
2206 {
2207 #[inline]
2208 fn encode(
2209 self,
2210 encoder_: &mut ___E,
2211 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmListChildrenRequest<'static>>,
2212 _: (),
2213 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2214 ::fidl_next::munge! {
2215 let crate::wire::RealmListChildrenRequest {
2216 collection,
2217 iter,
2218
2219 } = out_;
2220 }
2221
2222 ::fidl_next::Encode::encode(self.collection, encoder_, collection, ())?;
2223
2224 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(collection.as_mut_ptr()) };
2225
2226 ::fidl_next::Encode::encode(self.iter, encoder_, iter, ())?;
2227
2228 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iter.as_mut_ptr()) };
2229
2230 Ok(())
2231 }
2232 }
2233
2234 unsafe impl<___E>
2235 ::fidl_next::EncodeOption<
2236 ::fidl_next::wire::Box<'static, crate::wire::RealmListChildrenRequest<'static>>,
2237 ___E,
2238 > for RealmListChildrenRequest
2239 where
2240 ___E: ::fidl_next::Encoder + ?Sized,
2241 RealmListChildrenRequest:
2242 ::fidl_next::Encode<crate::wire::RealmListChildrenRequest<'static>, ___E>,
2243 {
2244 #[inline]
2245 fn encode_option(
2246 this: ::core::option::Option<Self>,
2247 encoder: &mut ___E,
2248 out: &mut ::core::mem::MaybeUninit<
2249 ::fidl_next::wire::Box<'static, crate::wire::RealmListChildrenRequest<'static>>,
2250 >,
2251 _: (),
2252 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2253 if let Some(inner) = this {
2254 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2255 ::fidl_next::wire::Box::encode_present(out);
2256 } else {
2257 ::fidl_next::wire::Box::encode_absent(out);
2258 }
2259
2260 Ok(())
2261 }
2262 }
2263
2264 impl<'de> ::fidl_next::FromWire<crate::wire::RealmListChildrenRequest<'de>>
2265 for RealmListChildrenRequest
2266 {
2267 #[inline]
2268 fn from_wire(wire: crate::wire::RealmListChildrenRequest<'de>) -> Self {
2269 Self {
2270 collection: ::fidl_next::FromWire::from_wire(wire.collection),
2271
2272 iter: ::fidl_next::FromWire::from_wire(wire.iter),
2273 }
2274 }
2275 }
2276
2277 #[derive(Debug, Clone, PartialEq)]
2278 pub struct RealmGetChildOutputDictionaryDeprecatedRequest {
2279 pub child: ::fidl_next_fuchsia_component_decl::natural::ChildRef,
2280 }
2281
2282 unsafe impl<___E>
2283 ::fidl_next::Encode<
2284 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
2285 ___E,
2286 > for RealmGetChildOutputDictionaryDeprecatedRequest
2287 where
2288 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2289 ___E: ::fidl_next::Encoder,
2290 ___E: ::fidl_next::fuchsia::HandleEncoder,
2291 {
2292 #[inline]
2293 fn encode(
2294 self,
2295 encoder_: &mut ___E,
2296 out_: &mut ::core::mem::MaybeUninit<
2297 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
2298 >,
2299 _: (),
2300 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2301 ::fidl_next::munge! {
2302 let crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest {
2303 child,
2304
2305 } = out_;
2306 }
2307
2308 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
2309
2310 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2311
2312 Ok(())
2313 }
2314 }
2315
2316 unsafe impl<___E>
2317 ::fidl_next::EncodeOption<
2318 ::fidl_next::wire::Box<
2319 'static,
2320 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
2321 >,
2322 ___E,
2323 > for RealmGetChildOutputDictionaryDeprecatedRequest
2324 where
2325 ___E: ::fidl_next::Encoder + ?Sized,
2326 RealmGetChildOutputDictionaryDeprecatedRequest: ::fidl_next::Encode<
2327 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
2328 ___E,
2329 >,
2330 {
2331 #[inline]
2332 fn encode_option(
2333 this: ::core::option::Option<Self>,
2334 encoder: &mut ___E,
2335 out: &mut ::core::mem::MaybeUninit<
2336 ::fidl_next::wire::Box<
2337 'static,
2338 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
2339 >,
2340 >,
2341 _: (),
2342 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2343 if let Some(inner) = this {
2344 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2345 ::fidl_next::wire::Box::encode_present(out);
2346 } else {
2347 ::fidl_next::wire::Box::encode_absent(out);
2348 }
2349
2350 Ok(())
2351 }
2352 }
2353
2354 impl<'de>
2355 ::fidl_next::FromWire<crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'de>>
2356 for RealmGetChildOutputDictionaryDeprecatedRequest
2357 {
2358 #[inline]
2359 fn from_wire(
2360 wire: crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'de>,
2361 ) -> Self {
2362 Self { child: ::fidl_next::FromWire::from_wire(wire.child) }
2363 }
2364 }
2365
2366 #[derive(Debug, PartialEq)]
2367 #[repr(C)]
2368 pub struct RealmGetChildOutputDictionaryDeprecatedResponse {
2369 pub dictionary: ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef,
2370 }
2371
2372 unsafe impl<___E>
2373 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse, ___E>
2374 for RealmGetChildOutputDictionaryDeprecatedResponse
2375 where
2376 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2377 ___E: ::fidl_next::fuchsia::HandleEncoder,
2378 {
2379 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2380 Self,
2381 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
2382 > = unsafe {
2383 ::fidl_next::CopyOptimization::enable_if(
2384 true
2385
2386 && <
2387 ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef as ::fidl_next::Encode<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef, ___E>
2388 >::COPY_OPTIMIZATION.is_enabled()
2389
2390 )
2391 };
2392
2393 #[inline]
2394 fn encode(
2395 self,
2396 encoder_: &mut ___E,
2397 out_: &mut ::core::mem::MaybeUninit<
2398 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
2399 >,
2400 _: (),
2401 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2402 ::fidl_next::munge! {
2403 let crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse {
2404 dictionary,
2405
2406 } = out_;
2407 }
2408
2409 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
2410
2411 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dictionary.as_mut_ptr()) };
2412
2413 Ok(())
2414 }
2415 }
2416
2417 unsafe impl<___E>
2418 ::fidl_next::EncodeOption<
2419 ::fidl_next::wire::Box<
2420 'static,
2421 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
2422 >,
2423 ___E,
2424 > for RealmGetChildOutputDictionaryDeprecatedResponse
2425 where
2426 ___E: ::fidl_next::Encoder + ?Sized,
2427 RealmGetChildOutputDictionaryDeprecatedResponse:
2428 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse, ___E>,
2429 {
2430 #[inline]
2431 fn encode_option(
2432 this: ::core::option::Option<Self>,
2433 encoder: &mut ___E,
2434 out: &mut ::core::mem::MaybeUninit<
2435 ::fidl_next::wire::Box<
2436 'static,
2437 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
2438 >,
2439 >,
2440 _: (),
2441 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2442 if let Some(inner) = this {
2443 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2444 ::fidl_next::wire::Box::encode_present(out);
2445 } else {
2446 ::fidl_next::wire::Box::encode_absent(out);
2447 }
2448
2449 Ok(())
2450 }
2451 }
2452
2453 impl ::fidl_next::FromWire<crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse>
2454 for RealmGetChildOutputDictionaryDeprecatedResponse
2455 {
2456 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2457 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
2458 Self,
2459 > = unsafe {
2460 ::fidl_next::CopyOptimization::enable_if(
2461 true
2462
2463 && <
2464 ::fidl_next_fuchsia_component_sandbox::natural::DictionaryRef as ::fidl_next::FromWire<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
2465 >::COPY_OPTIMIZATION.is_enabled()
2466
2467 )
2468 };
2469
2470 #[inline]
2471 fn from_wire(wire: crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse) -> Self {
2472 Self { dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary) }
2473 }
2474 }
2475
2476 #[derive(Debug, Clone, PartialEq)]
2477 pub struct RealmGetChildOutputDictionaryRequest {
2478 pub child: ::fidl_next_fuchsia_component_decl::natural::ChildRef,
2479 }
2480
2481 unsafe impl<___E>
2482 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryRequest<'static>, ___E>
2483 for RealmGetChildOutputDictionaryRequest
2484 where
2485 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2486 ___E: ::fidl_next::Encoder,
2487 ___E: ::fidl_next::fuchsia::HandleEncoder,
2488 {
2489 #[inline]
2490 fn encode(
2491 self,
2492 encoder_: &mut ___E,
2493 out_: &mut ::core::mem::MaybeUninit<
2494 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
2495 >,
2496 _: (),
2497 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2498 ::fidl_next::munge! {
2499 let crate::wire::RealmGetChildOutputDictionaryRequest {
2500 child,
2501
2502 } = out_;
2503 }
2504
2505 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
2506
2507 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2508
2509 Ok(())
2510 }
2511 }
2512
2513 unsafe impl<___E>
2514 ::fidl_next::EncodeOption<
2515 ::fidl_next::wire::Box<
2516 'static,
2517 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
2518 >,
2519 ___E,
2520 > for RealmGetChildOutputDictionaryRequest
2521 where
2522 ___E: ::fidl_next::Encoder + ?Sized,
2523 RealmGetChildOutputDictionaryRequest:
2524 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryRequest<'static>, ___E>,
2525 {
2526 #[inline]
2527 fn encode_option(
2528 this: ::core::option::Option<Self>,
2529 encoder: &mut ___E,
2530 out: &mut ::core::mem::MaybeUninit<
2531 ::fidl_next::wire::Box<
2532 'static,
2533 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
2534 >,
2535 >,
2536 _: (),
2537 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2538 if let Some(inner) = this {
2539 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2540 ::fidl_next::wire::Box::encode_present(out);
2541 } else {
2542 ::fidl_next::wire::Box::encode_absent(out);
2543 }
2544
2545 Ok(())
2546 }
2547 }
2548
2549 impl<'de> ::fidl_next::FromWire<crate::wire::RealmGetChildOutputDictionaryRequest<'de>>
2550 for RealmGetChildOutputDictionaryRequest
2551 {
2552 #[inline]
2553 fn from_wire(wire: crate::wire::RealmGetChildOutputDictionaryRequest<'de>) -> Self {
2554 Self { child: ::fidl_next::FromWire::from_wire(wire.child) }
2555 }
2556 }
2557
2558 #[derive(Debug, PartialEq)]
2559 #[repr(C)]
2560 pub struct RealmGetChildOutputDictionaryResponse {
2561 pub dictionary: ::fidl_next::fuchsia::zx::EventPair,
2562 }
2563
2564 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryResponse, ___E>
2565 for RealmGetChildOutputDictionaryResponse
2566 where
2567 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2568 ___E: ::fidl_next::fuchsia::HandleEncoder,
2569 {
2570 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2571 Self,
2572 crate::wire::RealmGetChildOutputDictionaryResponse,
2573 > = unsafe {
2574 ::fidl_next::CopyOptimization::enable_if(
2575 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::Encode<
2576 ::fidl_next::wire::fuchsia::EventPair,
2577 ___E,
2578 >>::COPY_OPTIMIZATION
2579 .is_enabled(),
2580 )
2581 };
2582
2583 #[inline]
2584 fn encode(
2585 self,
2586 encoder_: &mut ___E,
2587 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmGetChildOutputDictionaryResponse>,
2588 _: (),
2589 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2590 ::fidl_next::munge! {
2591 let crate::wire::RealmGetChildOutputDictionaryResponse {
2592 dictionary,
2593
2594 } = out_;
2595 }
2596
2597 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
2598
2599 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(dictionary.as_mut_ptr()) };
2600
2601 Ok(())
2602 }
2603 }
2604
2605 unsafe impl<___E>
2606 ::fidl_next::EncodeOption<
2607 ::fidl_next::wire::Box<'static, crate::wire::RealmGetChildOutputDictionaryResponse>,
2608 ___E,
2609 > for RealmGetChildOutputDictionaryResponse
2610 where
2611 ___E: ::fidl_next::Encoder + ?Sized,
2612 RealmGetChildOutputDictionaryResponse:
2613 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryResponse, ___E>,
2614 {
2615 #[inline]
2616 fn encode_option(
2617 this: ::core::option::Option<Self>,
2618 encoder: &mut ___E,
2619 out: &mut ::core::mem::MaybeUninit<
2620 ::fidl_next::wire::Box<'static, crate::wire::RealmGetChildOutputDictionaryResponse>,
2621 >,
2622 _: (),
2623 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2624 if let Some(inner) = this {
2625 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2626 ::fidl_next::wire::Box::encode_present(out);
2627 } else {
2628 ::fidl_next::wire::Box::encode_absent(out);
2629 }
2630
2631 Ok(())
2632 }
2633 }
2634
2635 impl ::fidl_next::FromWire<crate::wire::RealmGetChildOutputDictionaryResponse>
2636 for RealmGetChildOutputDictionaryResponse
2637 {
2638 const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<
2639 crate::wire::RealmGetChildOutputDictionaryResponse,
2640 Self,
2641 > = unsafe {
2642 ::fidl_next::CopyOptimization::enable_if(
2643 true && <::fidl_next::fuchsia::zx::EventPair as ::fidl_next::FromWire<
2644 ::fidl_next::wire::fuchsia::EventPair,
2645 >>::COPY_OPTIMIZATION
2646 .is_enabled(),
2647 )
2648 };
2649
2650 #[inline]
2651 fn from_wire(wire: crate::wire::RealmGetChildOutputDictionaryResponse) -> Self {
2652 Self { dictionary: ::fidl_next::FromWire::from_wire(wire.dictionary) }
2653 }
2654 }
2655
2656 #[derive(Debug, PartialEq)]
2657 pub struct RealmOpenControllerRequest {
2658 pub child: ::fidl_next_fuchsia_component_decl::natural::ChildRef,
2659
2660 pub controller:
2661 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::fuchsia::zx::Channel>,
2662 }
2663
2664 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmOpenControllerRequest<'static>, ___E>
2665 for RealmOpenControllerRequest
2666 where
2667 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2668 ___E: ::fidl_next::Encoder,
2669 ___E: ::fidl_next::fuchsia::HandleEncoder,
2670 {
2671 #[inline]
2672 fn encode(
2673 self,
2674 encoder_: &mut ___E,
2675 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmOpenControllerRequest<'static>>,
2676 _: (),
2677 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2678 ::fidl_next::munge! {
2679 let crate::wire::RealmOpenControllerRequest {
2680 child,
2681 controller,
2682
2683 } = out_;
2684 }
2685
2686 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
2687
2688 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2689
2690 ::fidl_next::Encode::encode(self.controller, encoder_, controller, ())?;
2691
2692 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(controller.as_mut_ptr()) };
2693
2694 Ok(())
2695 }
2696 }
2697
2698 unsafe impl<___E>
2699 ::fidl_next::EncodeOption<
2700 ::fidl_next::wire::Box<'static, crate::wire::RealmOpenControllerRequest<'static>>,
2701 ___E,
2702 > for RealmOpenControllerRequest
2703 where
2704 ___E: ::fidl_next::Encoder + ?Sized,
2705 RealmOpenControllerRequest:
2706 ::fidl_next::Encode<crate::wire::RealmOpenControllerRequest<'static>, ___E>,
2707 {
2708 #[inline]
2709 fn encode_option(
2710 this: ::core::option::Option<Self>,
2711 encoder: &mut ___E,
2712 out: &mut ::core::mem::MaybeUninit<
2713 ::fidl_next::wire::Box<'static, crate::wire::RealmOpenControllerRequest<'static>>,
2714 >,
2715 _: (),
2716 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2717 if let Some(inner) = this {
2718 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2719 ::fidl_next::wire::Box::encode_present(out);
2720 } else {
2721 ::fidl_next::wire::Box::encode_absent(out);
2722 }
2723
2724 Ok(())
2725 }
2726 }
2727
2728 impl<'de> ::fidl_next::FromWire<crate::wire::RealmOpenControllerRequest<'de>>
2729 for RealmOpenControllerRequest
2730 {
2731 #[inline]
2732 fn from_wire(wire: crate::wire::RealmOpenControllerRequest<'de>) -> Self {
2733 Self {
2734 child: ::fidl_next::FromWire::from_wire(wire.child),
2735
2736 controller: ::fidl_next::FromWire::from_wire(wire.controller),
2737 }
2738 }
2739 }
2740
2741 #[derive(Debug, PartialEq)]
2742 pub struct RealmOpenExposedDirRequest {
2743 pub child: ::fidl_next_fuchsia_component_decl::natural::ChildRef,
2744
2745 pub exposed_dir: ::fidl_next::ServerEnd<
2746 ::fidl_next_fuchsia_io::Directory,
2747 ::fidl_next::fuchsia::zx::Channel,
2748 >,
2749 }
2750
2751 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmOpenExposedDirRequest<'static>, ___E>
2752 for RealmOpenExposedDirRequest
2753 where
2754 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2755 ___E: ::fidl_next::Encoder,
2756 ___E: ::fidl_next::fuchsia::HandleEncoder,
2757 {
2758 #[inline]
2759 fn encode(
2760 self,
2761 encoder_: &mut ___E,
2762 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmOpenExposedDirRequest<'static>>,
2763 _: (),
2764 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2765 ::fidl_next::munge! {
2766 let crate::wire::RealmOpenExposedDirRequest {
2767 child,
2768 exposed_dir,
2769
2770 } = out_;
2771 }
2772
2773 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
2774
2775 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(child.as_mut_ptr()) };
2776
2777 ::fidl_next::Encode::encode(self.exposed_dir, encoder_, exposed_dir, ())?;
2778
2779 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(exposed_dir.as_mut_ptr()) };
2780
2781 Ok(())
2782 }
2783 }
2784
2785 unsafe impl<___E>
2786 ::fidl_next::EncodeOption<
2787 ::fidl_next::wire::Box<'static, crate::wire::RealmOpenExposedDirRequest<'static>>,
2788 ___E,
2789 > for RealmOpenExposedDirRequest
2790 where
2791 ___E: ::fidl_next::Encoder + ?Sized,
2792 RealmOpenExposedDirRequest:
2793 ::fidl_next::Encode<crate::wire::RealmOpenExposedDirRequest<'static>, ___E>,
2794 {
2795 #[inline]
2796 fn encode_option(
2797 this: ::core::option::Option<Self>,
2798 encoder: &mut ___E,
2799 out: &mut ::core::mem::MaybeUninit<
2800 ::fidl_next::wire::Box<'static, crate::wire::RealmOpenExposedDirRequest<'static>>,
2801 >,
2802 _: (),
2803 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2804 if let Some(inner) = this {
2805 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2806 ::fidl_next::wire::Box::encode_present(out);
2807 } else {
2808 ::fidl_next::wire::Box::encode_absent(out);
2809 }
2810
2811 Ok(())
2812 }
2813 }
2814
2815 impl<'de> ::fidl_next::FromWire<crate::wire::RealmOpenExposedDirRequest<'de>>
2816 for RealmOpenExposedDirRequest
2817 {
2818 #[inline]
2819 fn from_wire(wire: crate::wire::RealmOpenExposedDirRequest<'de>) -> Self {
2820 Self {
2821 child: ::fidl_next::FromWire::from_wire(wire.child),
2822
2823 exposed_dir: ::fidl_next::FromWire::from_wire(wire.exposed_dir),
2824 }
2825 }
2826 }
2827
2828 #[derive(Debug, PartialEq)]
2829 pub struct RealmCreateChildRequest {
2830 pub collection: ::fidl_next_fuchsia_component_decl::natural::CollectionRef,
2831
2832 pub decl: ::fidl_next_fuchsia_component_decl::natural::Child,
2833
2834 pub args: crate::natural::CreateChildArgs,
2835 }
2836
2837 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmCreateChildRequest<'static>, ___E>
2838 for RealmCreateChildRequest
2839 where
2840 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2841 ___E: ::fidl_next::Encoder,
2842 ___E: ::fidl_next::fuchsia::HandleEncoder,
2843 {
2844 #[inline]
2845 fn encode(
2846 self,
2847 encoder_: &mut ___E,
2848 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmCreateChildRequest<'static>>,
2849 _: (),
2850 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2851 ::fidl_next::munge! {
2852 let crate::wire::RealmCreateChildRequest {
2853 collection,
2854 decl,
2855 args,
2856
2857 } = out_;
2858 }
2859
2860 ::fidl_next::Encode::encode(self.collection, encoder_, collection, ())?;
2861
2862 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(collection.as_mut_ptr()) };
2863
2864 ::fidl_next::Encode::encode(self.decl, encoder_, decl, ())?;
2865
2866 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(decl.as_mut_ptr()) };
2867
2868 ::fidl_next::Encode::encode(self.args, encoder_, args, ())?;
2869
2870 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(args.as_mut_ptr()) };
2871
2872 Ok(())
2873 }
2874 }
2875
2876 unsafe impl<___E>
2877 ::fidl_next::EncodeOption<
2878 ::fidl_next::wire::Box<'static, crate::wire::RealmCreateChildRequest<'static>>,
2879 ___E,
2880 > for RealmCreateChildRequest
2881 where
2882 ___E: ::fidl_next::Encoder + ?Sized,
2883 RealmCreateChildRequest:
2884 ::fidl_next::Encode<crate::wire::RealmCreateChildRequest<'static>, ___E>,
2885 {
2886 #[inline]
2887 fn encode_option(
2888 this: ::core::option::Option<Self>,
2889 encoder: &mut ___E,
2890 out: &mut ::core::mem::MaybeUninit<
2891 ::fidl_next::wire::Box<'static, crate::wire::RealmCreateChildRequest<'static>>,
2892 >,
2893 _: (),
2894 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2895 if let Some(inner) = this {
2896 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2897 ::fidl_next::wire::Box::encode_present(out);
2898 } else {
2899 ::fidl_next::wire::Box::encode_absent(out);
2900 }
2901
2902 Ok(())
2903 }
2904 }
2905
2906 impl<'de> ::fidl_next::FromWire<crate::wire::RealmCreateChildRequest<'de>>
2907 for RealmCreateChildRequest
2908 {
2909 #[inline]
2910 fn from_wire(wire: crate::wire::RealmCreateChildRequest<'de>) -> Self {
2911 Self {
2912 collection: ::fidl_next::FromWire::from_wire(wire.collection),
2913
2914 decl: ::fidl_next::FromWire::from_wire(wire.decl),
2915
2916 args: ::fidl_next::FromWire::from_wire(wire.args),
2917 }
2918 }
2919 }
2920
2921 #[derive(Debug, PartialEq)]
2922 pub struct RealmGetResolvedInfoResponse {
2923 pub resolved_info: ::fidl_next_fuchsia_component_resolution::natural::Component,
2924 }
2925
2926 unsafe impl<___E> ::fidl_next::Encode<crate::wire::RealmGetResolvedInfoResponse<'static>, ___E>
2927 for RealmGetResolvedInfoResponse
2928 where
2929 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
2930 ___E: ::fidl_next::Encoder,
2931 ___E: ::fidl_next::fuchsia::HandleEncoder,
2932 {
2933 #[inline]
2934 fn encode(
2935 self,
2936 encoder_: &mut ___E,
2937 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmGetResolvedInfoResponse<'static>>,
2938 _: (),
2939 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2940 ::fidl_next::munge! {
2941 let crate::wire::RealmGetResolvedInfoResponse {
2942 resolved_info,
2943
2944 } = out_;
2945 }
2946
2947 ::fidl_next::Encode::encode(self.resolved_info, encoder_, resolved_info, ())?;
2948
2949 let mut _field =
2950 unsafe { ::fidl_next::Slot::new_unchecked(resolved_info.as_mut_ptr()) };
2951
2952 Ok(())
2953 }
2954 }
2955
2956 unsafe impl<___E>
2957 ::fidl_next::EncodeOption<
2958 ::fidl_next::wire::Box<'static, crate::wire::RealmGetResolvedInfoResponse<'static>>,
2959 ___E,
2960 > for RealmGetResolvedInfoResponse
2961 where
2962 ___E: ::fidl_next::Encoder + ?Sized,
2963 RealmGetResolvedInfoResponse:
2964 ::fidl_next::Encode<crate::wire::RealmGetResolvedInfoResponse<'static>, ___E>,
2965 {
2966 #[inline]
2967 fn encode_option(
2968 this: ::core::option::Option<Self>,
2969 encoder: &mut ___E,
2970 out: &mut ::core::mem::MaybeUninit<
2971 ::fidl_next::wire::Box<'static, crate::wire::RealmGetResolvedInfoResponse<'static>>,
2972 >,
2973 _: (),
2974 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
2975 if let Some(inner) = this {
2976 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
2977 ::fidl_next::wire::Box::encode_present(out);
2978 } else {
2979 ::fidl_next::wire::Box::encode_absent(out);
2980 }
2981
2982 Ok(())
2983 }
2984 }
2985
2986 impl<'de> ::fidl_next::FromWire<crate::wire::RealmGetResolvedInfoResponse<'de>>
2987 for RealmGetResolvedInfoResponse
2988 {
2989 #[inline]
2990 fn from_wire(wire: crate::wire::RealmGetResolvedInfoResponse<'de>) -> Self {
2991 Self { resolved_info: ::fidl_next::FromWire::from_wire(wire.resolved_info) }
2992 }
2993 }
2994
2995 #[derive(Debug, PartialEq)]
2996 pub struct StorageAdminListStorageInRealmRequest {
2997 pub relative_moniker: ::std::string::String,
2998
2999 pub iterator:
3000 ::fidl_next::ServerEnd<crate::StorageIterator, ::fidl_next::fuchsia::zx::Channel>,
3001 }
3002
3003 unsafe impl<___E>
3004 ::fidl_next::Encode<crate::wire::StorageAdminListStorageInRealmRequest<'static>, ___E>
3005 for StorageAdminListStorageInRealmRequest
3006 where
3007 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3008 ___E: ::fidl_next::Encoder,
3009 ___E: ::fidl_next::fuchsia::HandleEncoder,
3010 {
3011 #[inline]
3012 fn encode(
3013 self,
3014 encoder_: &mut ___E,
3015 out_: &mut ::core::mem::MaybeUninit<
3016 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
3017 >,
3018 _: (),
3019 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3020 ::fidl_next::munge! {
3021 let crate::wire::StorageAdminListStorageInRealmRequest {
3022 relative_moniker,
3023 iterator,
3024
3025 } = out_;
3026 }
3027
3028 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
3029
3030 let mut _field =
3031 unsafe { ::fidl_next::Slot::new_unchecked(relative_moniker.as_mut_ptr()) };
3032 ::fidl_next::Constrained::validate(_field, 4096)?;
3033
3034 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
3035
3036 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(iterator.as_mut_ptr()) };
3037
3038 Ok(())
3039 }
3040 }
3041
3042 unsafe impl<___E>
3043 ::fidl_next::EncodeOption<
3044 ::fidl_next::wire::Box<
3045 'static,
3046 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
3047 >,
3048 ___E,
3049 > for StorageAdminListStorageInRealmRequest
3050 where
3051 ___E: ::fidl_next::Encoder + ?Sized,
3052 StorageAdminListStorageInRealmRequest:
3053 ::fidl_next::Encode<crate::wire::StorageAdminListStorageInRealmRequest<'static>, ___E>,
3054 {
3055 #[inline]
3056 fn encode_option(
3057 this: ::core::option::Option<Self>,
3058 encoder: &mut ___E,
3059 out: &mut ::core::mem::MaybeUninit<
3060 ::fidl_next::wire::Box<
3061 'static,
3062 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
3063 >,
3064 >,
3065 _: (),
3066 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3067 if let Some(inner) = this {
3068 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3069 ::fidl_next::wire::Box::encode_present(out);
3070 } else {
3071 ::fidl_next::wire::Box::encode_absent(out);
3072 }
3073
3074 Ok(())
3075 }
3076 }
3077
3078 impl<'de> ::fidl_next::FromWire<crate::wire::StorageAdminListStorageInRealmRequest<'de>>
3079 for StorageAdminListStorageInRealmRequest
3080 {
3081 #[inline]
3082 fn from_wire(wire: crate::wire::StorageAdminListStorageInRealmRequest<'de>) -> Self {
3083 Self {
3084 relative_moniker: ::fidl_next::FromWire::from_wire(wire.relative_moniker),
3085
3086 iterator: ::fidl_next::FromWire::from_wire(wire.iterator),
3087 }
3088 }
3089 }
3090
3091 #[derive(Debug, PartialEq)]
3092 pub struct StorageAdminOpenStorageRequest {
3093 pub relative_moniker: ::std::string::String,
3094
3095 pub object:
3096 ::fidl_next::ServerEnd<::fidl_next_fuchsia_io::Node, ::fidl_next::fuchsia::zx::Channel>,
3097 }
3098
3099 unsafe impl<___E>
3100 ::fidl_next::Encode<crate::wire::StorageAdminOpenStorageRequest<'static>, ___E>
3101 for StorageAdminOpenStorageRequest
3102 where
3103 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3104 ___E: ::fidl_next::Encoder,
3105 ___E: ::fidl_next::fuchsia::HandleEncoder,
3106 {
3107 #[inline]
3108 fn encode(
3109 self,
3110 encoder_: &mut ___E,
3111 out_: &mut ::core::mem::MaybeUninit<
3112 crate::wire::StorageAdminOpenStorageRequest<'static>,
3113 >,
3114 _: (),
3115 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3116 ::fidl_next::munge! {
3117 let crate::wire::StorageAdminOpenStorageRequest {
3118 relative_moniker,
3119 object,
3120
3121 } = out_;
3122 }
3123
3124 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
3125
3126 let mut _field =
3127 unsafe { ::fidl_next::Slot::new_unchecked(relative_moniker.as_mut_ptr()) };
3128 ::fidl_next::Constrained::validate(_field, 4096)?;
3129
3130 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
3131
3132 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(object.as_mut_ptr()) };
3133
3134 Ok(())
3135 }
3136 }
3137
3138 unsafe impl<___E>
3139 ::fidl_next::EncodeOption<
3140 ::fidl_next::wire::Box<'static, crate::wire::StorageAdminOpenStorageRequest<'static>>,
3141 ___E,
3142 > for StorageAdminOpenStorageRequest
3143 where
3144 ___E: ::fidl_next::Encoder + ?Sized,
3145 StorageAdminOpenStorageRequest:
3146 ::fidl_next::Encode<crate::wire::StorageAdminOpenStorageRequest<'static>, ___E>,
3147 {
3148 #[inline]
3149 fn encode_option(
3150 this: ::core::option::Option<Self>,
3151 encoder: &mut ___E,
3152 out: &mut ::core::mem::MaybeUninit<
3153 ::fidl_next::wire::Box<
3154 'static,
3155 crate::wire::StorageAdminOpenStorageRequest<'static>,
3156 >,
3157 >,
3158 _: (),
3159 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3160 if let Some(inner) = this {
3161 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3162 ::fidl_next::wire::Box::encode_present(out);
3163 } else {
3164 ::fidl_next::wire::Box::encode_absent(out);
3165 }
3166
3167 Ok(())
3168 }
3169 }
3170
3171 impl<'de> ::fidl_next::FromWire<crate::wire::StorageAdminOpenStorageRequest<'de>>
3172 for StorageAdminOpenStorageRequest
3173 {
3174 #[inline]
3175 fn from_wire(wire: crate::wire::StorageAdminOpenStorageRequest<'de>) -> Self {
3176 Self {
3177 relative_moniker: ::fidl_next::FromWire::from_wire(wire.relative_moniker),
3178
3179 object: ::fidl_next::FromWire::from_wire(wire.object),
3180 }
3181 }
3182 }
3183
3184 #[derive(Debug, PartialEq)]
3185 pub struct StorageAdminOpenComponentStorageByIdRequest {
3186 pub id: ::std::string::String,
3187
3188 pub object:
3189 ::fidl_next::ServerEnd<::fidl_next_fuchsia_io::Node, ::fidl_next::fuchsia::zx::Channel>,
3190 }
3191
3192 unsafe impl<___E>
3193 ::fidl_next::Encode<crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>, ___E>
3194 for StorageAdminOpenComponentStorageByIdRequest
3195 where
3196 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
3197 ___E: ::fidl_next::Encoder,
3198 ___E: ::fidl_next::fuchsia::HandleEncoder,
3199 {
3200 #[inline]
3201 fn encode(
3202 self,
3203 encoder_: &mut ___E,
3204 out_: &mut ::core::mem::MaybeUninit<
3205 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
3206 >,
3207 _: (),
3208 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3209 ::fidl_next::munge! {
3210 let crate::wire::StorageAdminOpenComponentStorageByIdRequest {
3211 id,
3212 object,
3213
3214 } = out_;
3215 }
3216
3217 ::fidl_next::Encode::encode(self.id, encoder_, id, 64)?;
3218
3219 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(id.as_mut_ptr()) };
3220 ::fidl_next::Constrained::validate(_field, 64)?;
3221
3222 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
3223
3224 let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(object.as_mut_ptr()) };
3225
3226 Ok(())
3227 }
3228 }
3229
3230 unsafe impl<___E>
3231 ::fidl_next::EncodeOption<
3232 ::fidl_next::wire::Box<
3233 'static,
3234 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
3235 >,
3236 ___E,
3237 > for StorageAdminOpenComponentStorageByIdRequest
3238 where
3239 ___E: ::fidl_next::Encoder + ?Sized,
3240 StorageAdminOpenComponentStorageByIdRequest: ::fidl_next::Encode<
3241 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
3242 ___E,
3243 >,
3244 {
3245 #[inline]
3246 fn encode_option(
3247 this: ::core::option::Option<Self>,
3248 encoder: &mut ___E,
3249 out: &mut ::core::mem::MaybeUninit<
3250 ::fidl_next::wire::Box<
3251 'static,
3252 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
3253 >,
3254 >,
3255 _: (),
3256 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
3257 if let Some(inner) = this {
3258 ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
3259 ::fidl_next::wire::Box::encode_present(out);
3260 } else {
3261 ::fidl_next::wire::Box::encode_absent(out);
3262 }
3263
3264 Ok(())
3265 }
3266 }
3267
3268 impl<'de> ::fidl_next::FromWire<crate::wire::StorageAdminOpenComponentStorageByIdRequest<'de>>
3269 for StorageAdminOpenComponentStorageByIdRequest
3270 {
3271 #[inline]
3272 fn from_wire(wire: crate::wire::StorageAdminOpenComponentStorageByIdRequest<'de>) -> Self {
3273 Self {
3274 id: ::fidl_next::FromWire::from_wire(wire.id),
3275
3276 object: ::fidl_next::FromWire::from_wire(wire.object),
3277 }
3278 }
3279 }
3280}
3281
3282pub mod wire {
3283
3284 pub use fidl_next_common_fuchsia_component::wire::*;
3285
3286 #[repr(C)]
3288 pub struct CapabilityRequestedPayload<'de> {
3289 pub(crate) table: ::fidl_next::wire::Table<'de>,
3290 }
3291
3292 impl<'de> Drop for CapabilityRequestedPayload<'de> {
3293 fn drop(&mut self) {
3294 let _ = self.table.get(1).map(|envelope| unsafe {
3295 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
3296 });
3297
3298 let _ = self.table.get(2).map(|envelope| unsafe {
3299 envelope.read_unchecked::<::fidl_next::wire::fuchsia::Channel>()
3300 });
3301 }
3302 }
3303
3304 impl ::fidl_next::Constrained for CapabilityRequestedPayload<'_> {
3305 type Constraint = ();
3306
3307 fn validate(
3308 _: ::fidl_next::Slot<'_, Self>,
3309 _: Self::Constraint,
3310 ) -> Result<(), ::fidl_next::ValidationError> {
3311 Ok(())
3312 }
3313 }
3314
3315 unsafe impl ::fidl_next::Wire for CapabilityRequestedPayload<'static> {
3316 type Narrowed<'de> = CapabilityRequestedPayload<'de>;
3317
3318 #[inline]
3319 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3320 ::fidl_next::munge!(let Self { table } = out);
3321 ::fidl_next::wire::Table::zero_padding(table);
3322 }
3323 }
3324
3325 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CapabilityRequestedPayload<'de>
3326 where
3327 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3328 ___D: ::fidl_next::fuchsia::HandleDecoder,
3329 {
3330 fn decode(
3331 slot: ::fidl_next::Slot<'_, Self>,
3332 decoder: &mut ___D,
3333 _: (),
3334 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3335 ::fidl_next::munge!(let Self { table } = slot);
3336
3337 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3338 match ordinal {
3339 0 => unsafe { ::core::hint::unreachable_unchecked() },
3340
3341 1 => {
3342 ::fidl_next::wire::Envelope::decode_as::<
3343 ___D,
3344 ::fidl_next::wire::String<'de>,
3345 >(slot.as_mut(), decoder, 255)?;
3346
3347 let value = unsafe {
3348 slot.deref_unchecked()
3349 .deref_unchecked::<::fidl_next::wire::String<'_>>()
3350 };
3351
3352 if value.len() > 255 {
3353 return Err(::fidl_next::DecodeError::VectorTooLong {
3354 size: value.len() as u64,
3355 limit: 255,
3356 });
3357 }
3358
3359 Ok(())
3360 }
3361
3362 2 => {
3363 ::fidl_next::wire::Envelope::decode_as::<
3364 ___D,
3365 ::fidl_next::wire::fuchsia::Channel,
3366 >(slot.as_mut(), decoder, ())?;
3367
3368 Ok(())
3369 }
3370
3371 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3372 }
3373 })
3374 }
3375 }
3376
3377 impl<'de> CapabilityRequestedPayload<'de> {
3378 pub fn name(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
3379 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3380 }
3381
3382 pub fn capability(&self) -> ::core::option::Option<&::fidl_next::wire::fuchsia::Channel> {
3383 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3384 }
3385 }
3386
3387 impl<'de> ::core::fmt::Debug for CapabilityRequestedPayload<'de> {
3388 fn fmt(
3389 &self,
3390 f: &mut ::core::fmt::Formatter<'_>,
3391 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3392 f.debug_struct("CapabilityRequestedPayload")
3393 .field("name", &self.name())
3394 .field("capability", &self.capability())
3395 .finish()
3396 }
3397 }
3398
3399 impl<'de> ::fidl_next::IntoNatural for CapabilityRequestedPayload<'de> {
3400 type Natural = crate::natural::CapabilityRequestedPayload;
3401 }
3402
3403 #[derive(Debug)]
3405 #[repr(C)]
3406 pub struct ControllerIsStartedResponse {
3407 pub is_started: bool,
3408 }
3409
3410 static_assertions::const_assert_eq!(std::mem::size_of::<ControllerIsStartedResponse>(), 1);
3411 static_assertions::const_assert_eq!(std::mem::align_of::<ControllerIsStartedResponse>(), 1);
3412
3413 static_assertions::const_assert_eq!(
3414 std::mem::offset_of!(ControllerIsStartedResponse, is_started),
3415 0
3416 );
3417
3418 impl ::fidl_next::Constrained for ControllerIsStartedResponse {
3419 type Constraint = ();
3420
3421 fn validate(
3422 _: ::fidl_next::Slot<'_, Self>,
3423 _: Self::Constraint,
3424 ) -> Result<(), ::fidl_next::ValidationError> {
3425 Ok(())
3426 }
3427 }
3428
3429 unsafe impl ::fidl_next::Wire for ControllerIsStartedResponse {
3430 type Narrowed<'de> = ControllerIsStartedResponse;
3431
3432 #[inline]
3433 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3434 ::fidl_next::munge! {
3435 let Self {
3436 is_started,
3437
3438 } = &mut *out_;
3439 }
3440
3441 ::fidl_next::Wire::zero_padding(is_started);
3442 }
3443 }
3444
3445 unsafe impl<___D> ::fidl_next::Decode<___D> for ControllerIsStartedResponse
3446 where
3447 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3448 ___D: ::fidl_next::fuchsia::HandleDecoder,
3449 {
3450 fn decode(
3451 slot_: ::fidl_next::Slot<'_, Self>,
3452 decoder_: &mut ___D,
3453 _: (),
3454 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3455 ::fidl_next::munge! {
3456 let Self {
3457 mut is_started,
3458
3459 } = slot_;
3460 }
3461
3462 let _field = is_started.as_mut();
3463
3464 ::fidl_next::Decode::decode(is_started.as_mut(), decoder_, ())?;
3465
3466 Ok(())
3467 }
3468 }
3469
3470 impl ::fidl_next::IntoNatural for ControllerIsStartedResponse {
3471 type Natural = crate::natural::ControllerIsStartedResponse;
3472 }
3473
3474 #[derive(Debug)]
3476 #[repr(C)]
3477 pub struct ControllerGetExposedDictionaryResponse {
3478 pub dictionary: ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
3479 }
3480
3481 static_assertions::const_assert_eq!(
3482 std::mem::size_of::<ControllerGetExposedDictionaryResponse>(),
3483 4
3484 );
3485 static_assertions::const_assert_eq!(
3486 std::mem::align_of::<ControllerGetExposedDictionaryResponse>(),
3487 4
3488 );
3489
3490 static_assertions::const_assert_eq!(
3491 std::mem::offset_of!(ControllerGetExposedDictionaryResponse, dictionary),
3492 0
3493 );
3494
3495 impl ::fidl_next::Constrained for ControllerGetExposedDictionaryResponse {
3496 type Constraint = ();
3497
3498 fn validate(
3499 _: ::fidl_next::Slot<'_, Self>,
3500 _: Self::Constraint,
3501 ) -> Result<(), ::fidl_next::ValidationError> {
3502 Ok(())
3503 }
3504 }
3505
3506 unsafe impl ::fidl_next::Wire for ControllerGetExposedDictionaryResponse {
3507 type Narrowed<'de> = ControllerGetExposedDictionaryResponse;
3508
3509 #[inline]
3510 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3511 ::fidl_next::munge! {
3512 let Self {
3513 dictionary,
3514
3515 } = &mut *out_;
3516 }
3517
3518 ::fidl_next::Wire::zero_padding(dictionary);
3519 }
3520 }
3521
3522 unsafe impl<___D> ::fidl_next::Decode<___D> for ControllerGetExposedDictionaryResponse
3523 where
3524 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3525 ___D: ::fidl_next::fuchsia::HandleDecoder,
3526 {
3527 fn decode(
3528 slot_: ::fidl_next::Slot<'_, Self>,
3529 decoder_: &mut ___D,
3530 _: (),
3531 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3532 ::fidl_next::munge! {
3533 let Self {
3534 mut dictionary,
3535
3536 } = slot_;
3537 }
3538
3539 let _field = dictionary.as_mut();
3540
3541 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
3542
3543 Ok(())
3544 }
3545 }
3546
3547 impl ::fidl_next::IntoNatural for ControllerGetExposedDictionaryResponse {
3548 type Natural = crate::natural::ControllerGetExposedDictionaryResponse;
3549 }
3550
3551 #[derive(Debug)]
3553 #[repr(C)]
3554 pub struct ControllerGetOutputDictionaryResponse {
3555 pub dictionary: ::fidl_next::wire::fuchsia::EventPair,
3556 }
3557
3558 static_assertions::const_assert_eq!(
3559 std::mem::size_of::<ControllerGetOutputDictionaryResponse>(),
3560 4
3561 );
3562 static_assertions::const_assert_eq!(
3563 std::mem::align_of::<ControllerGetOutputDictionaryResponse>(),
3564 4
3565 );
3566
3567 static_assertions::const_assert_eq!(
3568 std::mem::offset_of!(ControllerGetOutputDictionaryResponse, dictionary),
3569 0
3570 );
3571
3572 impl ::fidl_next::Constrained for ControllerGetOutputDictionaryResponse {
3573 type Constraint = ();
3574
3575 fn validate(
3576 _: ::fidl_next::Slot<'_, Self>,
3577 _: Self::Constraint,
3578 ) -> Result<(), ::fidl_next::ValidationError> {
3579 Ok(())
3580 }
3581 }
3582
3583 unsafe impl ::fidl_next::Wire for ControllerGetOutputDictionaryResponse {
3584 type Narrowed<'de> = ControllerGetOutputDictionaryResponse;
3585
3586 #[inline]
3587 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3588 ::fidl_next::munge! {
3589 let Self {
3590 dictionary,
3591
3592 } = &mut *out_;
3593 }
3594
3595 ::fidl_next::Wire::zero_padding(dictionary);
3596 }
3597 }
3598
3599 unsafe impl<___D> ::fidl_next::Decode<___D> for ControllerGetOutputDictionaryResponse
3600 where
3601 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
3602 ___D: ::fidl_next::fuchsia::HandleDecoder,
3603 {
3604 fn decode(
3605 slot_: ::fidl_next::Slot<'_, Self>,
3606 decoder_: &mut ___D,
3607 _: (),
3608 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3609 ::fidl_next::munge! {
3610 let Self {
3611 mut dictionary,
3612
3613 } = slot_;
3614 }
3615
3616 let _field = dictionary.as_mut();
3617
3618 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
3619
3620 Ok(())
3621 }
3622 }
3623
3624 impl ::fidl_next::IntoNatural for ControllerGetOutputDictionaryResponse {
3625 type Natural = crate::natural::ControllerGetOutputDictionaryResponse;
3626 }
3627
3628 #[repr(C)]
3630 pub struct NamespaceEntry<'de> {
3631 pub(crate) table: ::fidl_next::wire::Table<'de>,
3632 }
3633
3634 impl<'de> Drop for NamespaceEntry<'de> {
3635 fn drop(&mut self) {
3636 let _ = self.table.get(1).map(|envelope| unsafe {
3637 envelope.read_unchecked::<::fidl_next::wire::String<'de>>()
3638 });
3639
3640 let _ = self.table.get(2).map(|envelope| unsafe {
3641 envelope.read_unchecked::<::fidl_next::ClientEnd<
3642 ::fidl_next_fuchsia_io::Directory,
3643 ::fidl_next::wire::fuchsia::Channel,
3644 >>()
3645 });
3646 }
3647 }
3648
3649 impl ::fidl_next::Constrained for NamespaceEntry<'_> {
3650 type Constraint = ();
3651
3652 fn validate(
3653 _: ::fidl_next::Slot<'_, Self>,
3654 _: Self::Constraint,
3655 ) -> Result<(), ::fidl_next::ValidationError> {
3656 Ok(())
3657 }
3658 }
3659
3660 unsafe impl ::fidl_next::Wire for NamespaceEntry<'static> {
3661 type Narrowed<'de> = NamespaceEntry<'de>;
3662
3663 #[inline]
3664 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3665 ::fidl_next::munge!(let Self { table } = out);
3666 ::fidl_next::wire::Table::zero_padding(table);
3667 }
3668 }
3669
3670 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceEntry<'de>
3671 where
3672 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3673 ___D: ::fidl_next::fuchsia::HandleDecoder,
3674 {
3675 fn decode(
3676 slot: ::fidl_next::Slot<'_, Self>,
3677 decoder: &mut ___D,
3678 _: (),
3679 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3680 ::fidl_next::munge!(let Self { table } = slot);
3681
3682 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3683 match ordinal {
3684 0 => unsafe { ::core::hint::unreachable_unchecked() },
3685
3686 1 => {
3687 ::fidl_next::wire::Envelope::decode_as::<
3688 ___D,
3689 ::fidl_next::wire::String<'de>,
3690 >(slot.as_mut(), decoder, 4095)?;
3691
3692 let value = unsafe {
3693 slot.deref_unchecked()
3694 .deref_unchecked::<::fidl_next::wire::String<'_>>()
3695 };
3696
3697 if value.len() > 4095 {
3698 return Err(::fidl_next::DecodeError::VectorTooLong {
3699 size: value.len() as u64,
3700 limit: 4095,
3701 });
3702 }
3703
3704 Ok(())
3705 }
3706
3707 2 => {
3708 ::fidl_next::wire::Envelope::decode_as::<
3709 ___D,
3710 ::fidl_next::ClientEnd<
3711 ::fidl_next_fuchsia_io::Directory,
3712 ::fidl_next::wire::fuchsia::Channel,
3713 >,
3714 >(slot.as_mut(), decoder, ())?;
3715
3716 Ok(())
3717 }
3718
3719 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3720 }
3721 })
3722 }
3723 }
3724
3725 impl<'de> NamespaceEntry<'de> {
3726 pub fn path(&self) -> ::core::option::Option<&::fidl_next::wire::String<'de>> {
3727 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3728 }
3729
3730 pub fn directory(
3731 &self,
3732 ) -> ::core::option::Option<
3733 &::fidl_next::ClientEnd<
3734 ::fidl_next_fuchsia_io::Directory,
3735 ::fidl_next::wire::fuchsia::Channel,
3736 >,
3737 > {
3738 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3739 }
3740 }
3741
3742 impl<'de> ::core::fmt::Debug for NamespaceEntry<'de> {
3743 fn fmt(
3744 &self,
3745 f: &mut ::core::fmt::Formatter<'_>,
3746 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3747 f.debug_struct("NamespaceEntry")
3748 .field("path", &self.path())
3749 .field("directory", &self.directory())
3750 .finish()
3751 }
3752 }
3753
3754 impl<'de> ::fidl_next::IntoNatural for NamespaceEntry<'de> {
3755 type Natural = crate::natural::NamespaceEntry;
3756 }
3757
3758 #[repr(C)]
3760 pub struct StartChildArgs<'de> {
3761 pub(crate) table: ::fidl_next::wire::Table<'de>,
3762 }
3763
3764 impl<'de> Drop for StartChildArgs<'de> {
3765 fn drop(&mut self) {
3766 let _ =
3767 self.table.get(1).map(|envelope| unsafe {
3768 envelope.read_unchecked::<::fidl_next::wire::Vector<
3769 'de,
3770 ::fidl_next_fuchsia_process::wire::HandleInfo,
3771 >>()
3772 });
3773
3774 let _ = self.table.get(2)
3775 .map(|envelope| unsafe {
3776 envelope.read_unchecked::<::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>>()
3777 });
3778
3779 let _ = self.table.get(3)
3780 .map(|envelope| unsafe {
3781 envelope.read_unchecked::<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>()
3782 });
3783
3784 let _ = self.table.get(4).map(|envelope| unsafe {
3785 envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>()
3786 });
3787 }
3788 }
3789
3790 impl ::fidl_next::Constrained for StartChildArgs<'_> {
3791 type Constraint = ();
3792
3793 fn validate(
3794 _: ::fidl_next::Slot<'_, Self>,
3795 _: Self::Constraint,
3796 ) -> Result<(), ::fidl_next::ValidationError> {
3797 Ok(())
3798 }
3799 }
3800
3801 unsafe impl ::fidl_next::Wire for StartChildArgs<'static> {
3802 type Narrowed<'de> = StartChildArgs<'de>;
3803
3804 #[inline]
3805 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
3806 ::fidl_next::munge!(let Self { table } = out);
3807 ::fidl_next::wire::Table::zero_padding(table);
3808 }
3809 }
3810
3811 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StartChildArgs<'de>
3812 where
3813 ___D: ::fidl_next::Decoder<'de> + ?Sized,
3814 ___D: ::fidl_next::fuchsia::HandleDecoder,
3815 {
3816 fn decode(
3817 slot: ::fidl_next::Slot<'_, Self>,
3818 decoder: &mut ___D,
3819 _: (),
3820 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
3821 ::fidl_next::munge!(let Self { table } = slot);
3822
3823 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
3824 match ordinal {
3825 0 => unsafe { ::core::hint::unreachable_unchecked() },
3826
3827 1 => {
3828 ::fidl_next::wire::Envelope::decode_as::<
3829 ___D,
3830 ::fidl_next::wire::Vector<
3831 'de,
3832 ::fidl_next_fuchsia_process::wire::HandleInfo,
3833 >,
3834 >(slot.as_mut(), decoder, (128, ()))?;
3835
3836 let value = unsafe {
3837 slot.deref_unchecked().deref_unchecked::<::fidl_next::wire::Vector<
3838 '_,
3839 ::fidl_next_fuchsia_process::wire::HandleInfo,
3840 >>()
3841 };
3842
3843 if value.len() > 128 {
3844 return Err(::fidl_next::DecodeError::VectorTooLong {
3845 size: value.len() as u64,
3846 limit: 128,
3847 });
3848 }
3849
3850 Ok(())
3851 }
3852
3853 2 => {
3854 ::fidl_next::wire::Envelope::decode_as::<
3855 ___D,
3856 ::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>,
3857 >(slot.as_mut(), decoder, (32, ()))?;
3858
3859 let value = unsafe {
3860 slot
3861 .deref_unchecked()
3862 .deref_unchecked::<
3863 ::fidl_next::wire::Vector<'_, crate::wire::NamespaceEntry<'_>>
3864 >()
3865 };
3866
3867 if value.len() > 32 {
3868 return Err(::fidl_next::DecodeError::VectorTooLong {
3869 size: value.len() as u64,
3870 limit: 32,
3871 });
3872 }
3873
3874 Ok(())
3875 }
3876
3877 3 => {
3878 ::fidl_next::wire::Envelope::decode_as::<
3879 ___D,
3880 ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
3881 >(slot.as_mut(), decoder, ())?;
3882
3883 Ok(())
3884 }
3885
3886 4 => {
3887 ::fidl_next::wire::Envelope::decode_as::<
3888 ___D,
3889 ::fidl_next::wire::fuchsia::EventPair,
3890 >(slot.as_mut(), decoder, ())?;
3891
3892 Ok(())
3893 }
3894
3895 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
3896 }
3897 })
3898 }
3899 }
3900
3901 impl<'de> StartChildArgs<'de> {
3902 pub fn numbered_handles(
3903 &self,
3904 ) -> ::core::option::Option<
3905 &::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>,
3906 > {
3907 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
3908 }
3909
3910 pub fn namespace_entries(
3911 &self,
3912 ) -> ::core::option::Option<&::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>>
3913 {
3914 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
3915 }
3916
3917 pub fn dictionary(
3918 &self,
3919 ) -> ::core::option::Option<&::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
3920 {
3921 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
3922 }
3923
3924 pub fn additional_inputs(
3925 &self,
3926 ) -> ::core::option::Option<&::fidl_next::wire::fuchsia::EventPair> {
3927 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
3928 }
3929 }
3930
3931 impl<'de> ::core::fmt::Debug for StartChildArgs<'de> {
3932 fn fmt(
3933 &self,
3934 f: &mut ::core::fmt::Formatter<'_>,
3935 ) -> ::core::result::Result<(), ::core::fmt::Error> {
3936 f.debug_struct("StartChildArgs")
3937 .field("numbered_handles", &self.numbered_handles())
3938 .field("namespace_entries", &self.namespace_entries())
3939 .field("dictionary", &self.dictionary())
3940 .field("additional_inputs", &self.additional_inputs())
3941 .finish()
3942 }
3943 }
3944
3945 impl<'de> ::fidl_next::IntoNatural for StartChildArgs<'de> {
3946 type Natural = crate::natural::StartChildArgs;
3947 }
3948
3949 #[derive(Debug)]
3951 #[repr(C)]
3952 pub struct ControllerStartRequest<'de> {
3953 pub args: crate::wire::StartChildArgs<'de>,
3954
3955 pub execution_controller:
3956 ::fidl_next::ServerEnd<crate::ExecutionController, ::fidl_next::wire::fuchsia::Channel>,
3957 }
3958
3959 static_assertions::const_assert_eq!(std::mem::size_of::<ControllerStartRequest<'_>>(), 24);
3960 static_assertions::const_assert_eq!(std::mem::align_of::<ControllerStartRequest<'_>>(), 8);
3961
3962 static_assertions::const_assert_eq!(std::mem::offset_of!(ControllerStartRequest<'_>, args), 0);
3963
3964 static_assertions::const_assert_eq!(
3965 std::mem::offset_of!(ControllerStartRequest<'_>, execution_controller),
3966 16
3967 );
3968
3969 impl ::fidl_next::Constrained for ControllerStartRequest<'_> {
3970 type Constraint = ();
3971
3972 fn validate(
3973 _: ::fidl_next::Slot<'_, Self>,
3974 _: Self::Constraint,
3975 ) -> Result<(), ::fidl_next::ValidationError> {
3976 Ok(())
3977 }
3978 }
3979
3980 unsafe impl ::fidl_next::Wire for ControllerStartRequest<'static> {
3981 type Narrowed<'de> = ControllerStartRequest<'de>;
3982
3983 #[inline]
3984 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
3985 ::fidl_next::munge! {
3986 let Self {
3987 args,
3988 execution_controller,
3989
3990 } = &mut *out_;
3991 }
3992
3993 ::fidl_next::Wire::zero_padding(args);
3994
3995 ::fidl_next::Wire::zero_padding(execution_controller);
3996
3997 unsafe {
3998 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
3999 }
4000 }
4001 }
4002
4003 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ControllerStartRequest<'de>
4004 where
4005 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4006 ___D: ::fidl_next::Decoder<'de>,
4007 ___D: ::fidl_next::fuchsia::HandleDecoder,
4008 {
4009 fn decode(
4010 slot_: ::fidl_next::Slot<'_, Self>,
4011 decoder_: &mut ___D,
4012 _: (),
4013 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4014 if slot_.as_bytes()[20..24] != [0u8; 4] {
4015 return Err(::fidl_next::DecodeError::InvalidPadding);
4016 }
4017
4018 ::fidl_next::munge! {
4019 let Self {
4020 mut args,
4021 mut execution_controller,
4022
4023 } = slot_;
4024 }
4025
4026 let _field = args.as_mut();
4027
4028 ::fidl_next::Decode::decode(args.as_mut(), decoder_, ())?;
4029
4030 let _field = execution_controller.as_mut();
4031
4032 ::fidl_next::Decode::decode(execution_controller.as_mut(), decoder_, ())?;
4033
4034 Ok(())
4035 }
4036 }
4037
4038 impl<'de> ::fidl_next::IntoNatural for ControllerStartRequest<'de> {
4039 type Natural = crate::natural::ControllerStartRequest;
4040 }
4041
4042 #[derive(Debug)]
4044 #[repr(C)]
4045 pub struct ControllerOpenExposedDirRequest {
4046 pub exposed_dir: ::fidl_next::ServerEnd<
4047 ::fidl_next_fuchsia_io::Directory,
4048 ::fidl_next::wire::fuchsia::Channel,
4049 >,
4050 }
4051
4052 static_assertions::const_assert_eq!(std::mem::size_of::<ControllerOpenExposedDirRequest>(), 4);
4053 static_assertions::const_assert_eq!(std::mem::align_of::<ControllerOpenExposedDirRequest>(), 4);
4054
4055 static_assertions::const_assert_eq!(
4056 std::mem::offset_of!(ControllerOpenExposedDirRequest, exposed_dir),
4057 0
4058 );
4059
4060 impl ::fidl_next::Constrained for ControllerOpenExposedDirRequest {
4061 type Constraint = ();
4062
4063 fn validate(
4064 _: ::fidl_next::Slot<'_, Self>,
4065 _: Self::Constraint,
4066 ) -> Result<(), ::fidl_next::ValidationError> {
4067 Ok(())
4068 }
4069 }
4070
4071 unsafe impl ::fidl_next::Wire for ControllerOpenExposedDirRequest {
4072 type Narrowed<'de> = ControllerOpenExposedDirRequest;
4073
4074 #[inline]
4075 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4076 ::fidl_next::munge! {
4077 let Self {
4078 exposed_dir,
4079
4080 } = &mut *out_;
4081 }
4082
4083 ::fidl_next::Wire::zero_padding(exposed_dir);
4084 }
4085 }
4086
4087 unsafe impl<___D> ::fidl_next::Decode<___D> for ControllerOpenExposedDirRequest
4088 where
4089 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4090 ___D: ::fidl_next::fuchsia::HandleDecoder,
4091 {
4092 fn decode(
4093 slot_: ::fidl_next::Slot<'_, Self>,
4094 decoder_: &mut ___D,
4095 _: (),
4096 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4097 ::fidl_next::munge! {
4098 let Self {
4099 mut exposed_dir,
4100
4101 } = slot_;
4102 }
4103
4104 let _field = exposed_dir.as_mut();
4105
4106 ::fidl_next::Decode::decode(exposed_dir.as_mut(), decoder_, ())?;
4107
4108 Ok(())
4109 }
4110 }
4111
4112 impl ::fidl_next::IntoNatural for ControllerOpenExposedDirRequest {
4113 type Natural = crate::natural::ControllerOpenExposedDirRequest;
4114 }
4115
4116 #[repr(C)]
4118 pub struct CreateChildArgs<'de> {
4119 pub(crate) table: ::fidl_next::wire::Table<'de>,
4120 }
4121
4122 impl<'de> Drop for CreateChildArgs<'de> {
4123 fn drop(&mut self) {
4124 let _ =
4125 self.table.get(1).map(|envelope| unsafe {
4126 envelope.read_unchecked::<::fidl_next::wire::Vector<
4127 'de,
4128 ::fidl_next_fuchsia_process::wire::HandleInfo,
4129 >>()
4130 });
4131
4132 let _ = self.table.get(2).map(|envelope| unsafe {
4133 envelope.read_unchecked::<::fidl_next::wire::Vector<
4134 'de,
4135 ::fidl_next_fuchsia_component_decl::wire::Offer<'de>,
4136 >>()
4137 });
4138
4139 let _ =
4140 self.table.get(3).map(|envelope| unsafe {
4141 envelope.read_unchecked::<::fidl_next::ServerEnd<
4142 crate::Controller,
4143 ::fidl_next::wire::fuchsia::Channel,
4144 >>()
4145 });
4146
4147 let _ = self.table.get(4)
4148 .map(|envelope| unsafe {
4149 envelope.read_unchecked::<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>()
4150 });
4151
4152 let _ = self.table.get(5).map(|envelope| unsafe {
4153 envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>()
4154 });
4155 }
4156 }
4157
4158 impl ::fidl_next::Constrained for CreateChildArgs<'_> {
4159 type Constraint = ();
4160
4161 fn validate(
4162 _: ::fidl_next::Slot<'_, Self>,
4163 _: Self::Constraint,
4164 ) -> Result<(), ::fidl_next::ValidationError> {
4165 Ok(())
4166 }
4167 }
4168
4169 unsafe impl ::fidl_next::Wire for CreateChildArgs<'static> {
4170 type Narrowed<'de> = CreateChildArgs<'de>;
4171
4172 #[inline]
4173 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4174 ::fidl_next::munge!(let Self { table } = out);
4175 ::fidl_next::wire::Table::zero_padding(table);
4176 }
4177 }
4178
4179 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for CreateChildArgs<'de>
4180 where
4181 ___D: ::fidl_next::Decoder<'de> + ?Sized,
4182 ___D: ::fidl_next::fuchsia::HandleDecoder,
4183 {
4184 fn decode(
4185 slot: ::fidl_next::Slot<'_, Self>,
4186 decoder: &mut ___D,
4187 _: (),
4188 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4189 ::fidl_next::munge!(let Self { table } = slot);
4190
4191 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
4192 match ordinal {
4193 0 => unsafe { ::core::hint::unreachable_unchecked() },
4194
4195 1 => {
4196 ::fidl_next::wire::Envelope::decode_as::<
4197 ___D,
4198 ::fidl_next::wire::Vector<
4199 'de,
4200 ::fidl_next_fuchsia_process::wire::HandleInfo,
4201 >,
4202 >(slot.as_mut(), decoder, (128, ()))?;
4203
4204 let value = unsafe {
4205 slot.deref_unchecked().deref_unchecked::<::fidl_next::wire::Vector<
4206 '_,
4207 ::fidl_next_fuchsia_process::wire::HandleInfo,
4208 >>()
4209 };
4210
4211 if value.len() > 128 {
4212 return Err(::fidl_next::DecodeError::VectorTooLong {
4213 size: value.len() as u64,
4214 limit: 128,
4215 });
4216 }
4217
4218 Ok(())
4219 }
4220
4221 2 => {
4222 ::fidl_next::wire::Envelope::decode_as::<
4223 ___D,
4224 ::fidl_next::wire::Vector<
4225 'de,
4226 ::fidl_next_fuchsia_component_decl::wire::Offer<'de>,
4227 >,
4228 >(slot.as_mut(), decoder, (128, ()))?;
4229
4230 let value = unsafe {
4231 slot.deref_unchecked().deref_unchecked::<::fidl_next::wire::Vector<
4232 '_,
4233 ::fidl_next_fuchsia_component_decl::wire::Offer<'_>,
4234 >>()
4235 };
4236
4237 if value.len() > 128 {
4238 return Err(::fidl_next::DecodeError::VectorTooLong {
4239 size: value.len() as u64,
4240 limit: 128,
4241 });
4242 }
4243
4244 Ok(())
4245 }
4246
4247 3 => {
4248 ::fidl_next::wire::Envelope::decode_as::<
4249 ___D,
4250 ::fidl_next::ServerEnd<
4251 crate::Controller,
4252 ::fidl_next::wire::fuchsia::Channel,
4253 >,
4254 >(slot.as_mut(), decoder, ())?;
4255
4256 Ok(())
4257 }
4258
4259 4 => {
4260 ::fidl_next::wire::Envelope::decode_as::<
4261 ___D,
4262 ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
4263 >(slot.as_mut(), decoder, ())?;
4264
4265 Ok(())
4266 }
4267
4268 5 => {
4269 ::fidl_next::wire::Envelope::decode_as::<
4270 ___D,
4271 ::fidl_next::wire::fuchsia::EventPair,
4272 >(slot.as_mut(), decoder, ())?;
4273
4274 Ok(())
4275 }
4276
4277 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
4278 }
4279 })
4280 }
4281 }
4282
4283 impl<'de> CreateChildArgs<'de> {
4284 pub fn numbered_handles(
4285 &self,
4286 ) -> ::core::option::Option<
4287 &::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_process::wire::HandleInfo>,
4288 > {
4289 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
4290 }
4291
4292 pub fn dynamic_offers(
4293 &self,
4294 ) -> ::core::option::Option<
4295 &::fidl_next::wire::Vector<'de, ::fidl_next_fuchsia_component_decl::wire::Offer<'de>>,
4296 > {
4297 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
4298 }
4299
4300 pub fn controller(
4301 &self,
4302 ) -> ::core::option::Option<
4303 &::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
4304 > {
4305 unsafe { Some(self.table.get(3)?.deref_unchecked()) }
4306 }
4307
4308 pub fn dictionary(
4309 &self,
4310 ) -> ::core::option::Option<&::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef>
4311 {
4312 unsafe { Some(self.table.get(4)?.deref_unchecked()) }
4313 }
4314
4315 pub fn additional_inputs(
4316 &self,
4317 ) -> ::core::option::Option<&::fidl_next::wire::fuchsia::EventPair> {
4318 unsafe { Some(self.table.get(5)?.deref_unchecked()) }
4319 }
4320 }
4321
4322 impl<'de> ::core::fmt::Debug for CreateChildArgs<'de> {
4323 fn fmt(
4324 &self,
4325 f: &mut ::core::fmt::Formatter<'_>,
4326 ) -> ::core::result::Result<(), ::core::fmt::Error> {
4327 f.debug_struct("CreateChildArgs")
4328 .field("numbered_handles", &self.numbered_handles())
4329 .field("dynamic_offers", &self.dynamic_offers())
4330 .field("controller", &self.controller())
4331 .field("dictionary", &self.dictionary())
4332 .field("additional_inputs", &self.additional_inputs())
4333 .finish()
4334 }
4335 }
4336
4337 impl<'de> ::fidl_next::IntoNatural for CreateChildArgs<'de> {
4338 type Natural = crate::natural::CreateChildArgs;
4339 }
4340
4341 #[repr(C)]
4343 pub struct DebugStartedPayload<'de> {
4344 pub(crate) table: ::fidl_next::wire::Table<'de>,
4345 }
4346
4347 impl<'de> Drop for DebugStartedPayload<'de> {
4348 fn drop(&mut self) {
4349 let _ = self.table.get(1).map(|envelope| unsafe {
4350 envelope.read_unchecked::<::fidl_next::ClientEnd<
4351 ::fidl_next_fuchsia_io::Directory,
4352 ::fidl_next::wire::fuchsia::Channel,
4353 >>()
4354 });
4355
4356 let _ = self.table.get(2).map(|envelope| unsafe {
4357 envelope.read_unchecked::<::fidl_next::wire::fuchsia::EventPair>()
4358 });
4359 }
4360 }
4361
4362 impl ::fidl_next::Constrained for DebugStartedPayload<'_> {
4363 type Constraint = ();
4364
4365 fn validate(
4366 _: ::fidl_next::Slot<'_, Self>,
4367 _: Self::Constraint,
4368 ) -> Result<(), ::fidl_next::ValidationError> {
4369 Ok(())
4370 }
4371 }
4372
4373 unsafe impl ::fidl_next::Wire for DebugStartedPayload<'static> {
4374 type Narrowed<'de> = DebugStartedPayload<'de>;
4375
4376 #[inline]
4377 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4378 ::fidl_next::munge!(let Self { table } = out);
4379 ::fidl_next::wire::Table::zero_padding(table);
4380 }
4381 }
4382
4383 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DebugStartedPayload<'de>
4384 where
4385 ___D: ::fidl_next::Decoder<'de> + ?Sized,
4386 ___D: ::fidl_next::fuchsia::HandleDecoder,
4387 {
4388 fn decode(
4389 slot: ::fidl_next::Slot<'_, Self>,
4390 decoder: &mut ___D,
4391 _: (),
4392 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4393 ::fidl_next::munge!(let Self { table } = slot);
4394
4395 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
4396 match ordinal {
4397 0 => unsafe { ::core::hint::unreachable_unchecked() },
4398
4399 1 => {
4400 ::fidl_next::wire::Envelope::decode_as::<
4401 ___D,
4402 ::fidl_next::ClientEnd<
4403 ::fidl_next_fuchsia_io::Directory,
4404 ::fidl_next::wire::fuchsia::Channel,
4405 >,
4406 >(slot.as_mut(), decoder, ())?;
4407
4408 Ok(())
4409 }
4410
4411 2 => {
4412 ::fidl_next::wire::Envelope::decode_as::<
4413 ___D,
4414 ::fidl_next::wire::fuchsia::EventPair,
4415 >(slot.as_mut(), decoder, ())?;
4416
4417 Ok(())
4418 }
4419
4420 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
4421 }
4422 })
4423 }
4424 }
4425
4426 impl<'de> DebugStartedPayload<'de> {
4427 pub fn runtime_dir(
4428 &self,
4429 ) -> ::core::option::Option<
4430 &::fidl_next::ClientEnd<
4431 ::fidl_next_fuchsia_io::Directory,
4432 ::fidl_next::wire::fuchsia::Channel,
4433 >,
4434 > {
4435 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
4436 }
4437
4438 pub fn break_on_start(
4439 &self,
4440 ) -> ::core::option::Option<&::fidl_next::wire::fuchsia::EventPair> {
4441 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
4442 }
4443 }
4444
4445 impl<'de> ::core::fmt::Debug for DebugStartedPayload<'de> {
4446 fn fmt(
4447 &self,
4448 f: &mut ::core::fmt::Formatter<'_>,
4449 ) -> ::core::result::Result<(), ::core::fmt::Error> {
4450 f.debug_struct("DebugStartedPayload")
4451 .field("runtime_dir", &self.runtime_dir())
4452 .field("break_on_start", &self.break_on_start())
4453 .finish()
4454 }
4455 }
4456
4457 impl<'de> ::fidl_next::IntoNatural for DebugStartedPayload<'de> {
4458 type Natural = crate::natural::DebugStartedPayload;
4459 }
4460
4461 #[repr(transparent)]
4463 pub struct EventPayload<'de> {
4464 pub(crate) raw: ::fidl_next::wire::Union,
4465 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
4466 }
4467
4468 impl<'de> Drop for EventPayload<'de> {
4469 fn drop(&mut self) {
4470 match self.raw.ordinal() {
4471 1 => {
4472 let _ = unsafe {
4473 self.raw
4474 .get()
4475 .read_unchecked::<crate::wire::CapabilityRequestedPayload<'de>>()
4476 };
4477 }
4478
4479 2 => {
4480 let _ = unsafe {
4481 self.raw.get().read_unchecked::<crate::wire::PurgedPayload<'de>>()
4482 };
4483 }
4484
4485 4 => {
4486 let _ = unsafe {
4487 self.raw.get().read_unchecked::<crate::wire::DiscoveredPayload<'de>>()
4488 };
4489 }
4490
4491 5 => {
4492 let _ = unsafe {
4493 self.raw.get().read_unchecked::<crate::wire::DestroyedPayload<'de>>()
4494 };
4495 }
4496
4497 6 => {
4498 let _ = unsafe {
4499 self.raw.get().read_unchecked::<crate::wire::ResolvedPayload<'de>>()
4500 };
4501 }
4502
4503 7 => {
4504 let _ = unsafe {
4505 self.raw.get().read_unchecked::<crate::wire::StartedPayload<'de>>()
4506 };
4507 }
4508
4509 8 => {
4510 let _ = unsafe {
4511 self.raw.get().read_unchecked::<crate::wire::StoppedPayload<'de>>()
4512 };
4513 }
4514
4515 9 => {
4516 let _ = unsafe {
4517 self.raw.get().read_unchecked::<crate::wire::DebugStartedPayload<'de>>()
4518 };
4519 }
4520
4521 10 => {
4522 let _ = unsafe {
4523 self.raw.get().read_unchecked::<crate::wire::UnresolvedPayload<'de>>()
4524 };
4525 }
4526
4527 _ => (),
4528 }
4529 }
4530 }
4531
4532 impl ::fidl_next::Constrained for EventPayload<'_> {
4533 type Constraint = ();
4534
4535 fn validate(
4536 _: ::fidl_next::Slot<'_, Self>,
4537 _: Self::Constraint,
4538 ) -> Result<(), ::fidl_next::ValidationError> {
4539 Ok(())
4540 }
4541 }
4542
4543 unsafe impl ::fidl_next::Wire for EventPayload<'static> {
4544 type Narrowed<'de> = EventPayload<'de>;
4545
4546 #[inline]
4547 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4548 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
4549 ::fidl_next::wire::Union::zero_padding(raw);
4550 }
4551 }
4552
4553 pub mod event_payload {
4554 pub enum Ref<'de> {
4555 CapabilityRequested(&'de crate::wire::CapabilityRequestedPayload<'de>),
4556
4557 Purged(&'de crate::wire::PurgedPayload<'de>),
4558
4559 Discovered(&'de crate::wire::DiscoveredPayload<'de>),
4560
4561 Destroyed(&'de crate::wire::DestroyedPayload<'de>),
4562
4563 Resolved(&'de crate::wire::ResolvedPayload<'de>),
4564
4565 Started(&'de crate::wire::StartedPayload<'de>),
4566
4567 Stopped(&'de crate::wire::StoppedPayload<'de>),
4568
4569 DebugStarted(&'de crate::wire::DebugStartedPayload<'de>),
4570
4571 Unresolved(&'de crate::wire::UnresolvedPayload<'de>),
4572
4573 UnknownOrdinal_(u64),
4574 }
4575 }
4576
4577 impl<'de> EventPayload<'de> {
4578 pub fn as_ref(&self) -> crate::wire::event_payload::Ref<'_> {
4579 match self.raw.ordinal() {
4580 1 => crate::wire::event_payload::Ref::CapabilityRequested(unsafe {
4581 self.raw.get().deref_unchecked::<crate::wire::CapabilityRequestedPayload<'_>>()
4582 }),
4583
4584 2 => crate::wire::event_payload::Ref::Purged(unsafe {
4585 self.raw.get().deref_unchecked::<crate::wire::PurgedPayload<'_>>()
4586 }),
4587
4588 4 => crate::wire::event_payload::Ref::Discovered(unsafe {
4589 self.raw.get().deref_unchecked::<crate::wire::DiscoveredPayload<'_>>()
4590 }),
4591
4592 5 => crate::wire::event_payload::Ref::Destroyed(unsafe {
4593 self.raw.get().deref_unchecked::<crate::wire::DestroyedPayload<'_>>()
4594 }),
4595
4596 6 => crate::wire::event_payload::Ref::Resolved(unsafe {
4597 self.raw.get().deref_unchecked::<crate::wire::ResolvedPayload<'_>>()
4598 }),
4599
4600 7 => crate::wire::event_payload::Ref::Started(unsafe {
4601 self.raw.get().deref_unchecked::<crate::wire::StartedPayload<'_>>()
4602 }),
4603
4604 8 => crate::wire::event_payload::Ref::Stopped(unsafe {
4605 self.raw.get().deref_unchecked::<crate::wire::StoppedPayload<'_>>()
4606 }),
4607
4608 9 => crate::wire::event_payload::Ref::DebugStarted(unsafe {
4609 self.raw.get().deref_unchecked::<crate::wire::DebugStartedPayload<'_>>()
4610 }),
4611
4612 10 => crate::wire::event_payload::Ref::Unresolved(unsafe {
4613 self.raw.get().deref_unchecked::<crate::wire::UnresolvedPayload<'_>>()
4614 }),
4615
4616 unknown => crate::wire::event_payload::Ref::UnknownOrdinal_(unknown),
4617 }
4618 }
4619 }
4620
4621 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EventPayload<'de>
4622 where
4623 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4624 ___D: ::fidl_next::Decoder<'de>,
4625 ___D: ::fidl_next::fuchsia::HandleDecoder,
4626 {
4627 fn decode(
4628 mut slot: ::fidl_next::Slot<'_, Self>,
4629 decoder: &mut ___D,
4630 _: (),
4631 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4632 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
4633 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
4634 1 => ::fidl_next::wire::Union::decode_as::<
4635 ___D,
4636 crate::wire::CapabilityRequestedPayload<'de>,
4637 >(raw, decoder, ())?,
4638
4639 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::PurgedPayload<'de>>(
4640 raw,
4641 decoder,
4642 (),
4643 )?,
4644
4645 4 => ::fidl_next::wire::Union::decode_as::<
4646 ___D,
4647 crate::wire::DiscoveredPayload<'de>,
4648 >(raw, decoder, ())?,
4649
4650 5 => {
4651 ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DestroyedPayload<'de>>(
4652 raw,
4653 decoder,
4654 (),
4655 )?
4656 }
4657
4658 6 => {
4659 ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ResolvedPayload<'de>>(
4660 raw,
4661 decoder,
4662 (),
4663 )?
4664 }
4665
4666 7 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::StartedPayload<'de>>(
4667 raw,
4668 decoder,
4669 (),
4670 )?,
4671
4672 8 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::StoppedPayload<'de>>(
4673 raw,
4674 decoder,
4675 (),
4676 )?,
4677
4678 9 => ::fidl_next::wire::Union::decode_as::<
4679 ___D,
4680 crate::wire::DebugStartedPayload<'de>,
4681 >(raw, decoder, ())?,
4682
4683 10 => ::fidl_next::wire::Union::decode_as::<
4684 ___D,
4685 crate::wire::UnresolvedPayload<'de>,
4686 >(raw, decoder, ())?,
4687
4688 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
4689 }
4690
4691 Ok(())
4692 }
4693 }
4694
4695 impl<'de> ::core::fmt::Debug for EventPayload<'de> {
4696 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4697 match self.raw.ordinal() {
4698 1 => unsafe {
4699 self.raw
4700 .get()
4701 .deref_unchecked::<crate::wire::CapabilityRequestedPayload<'_>>()
4702 .fmt(f)
4703 },
4704 2 => unsafe {
4705 self.raw.get().deref_unchecked::<crate::wire::PurgedPayload<'_>>().fmt(f)
4706 },
4707 4 => unsafe {
4708 self.raw.get().deref_unchecked::<crate::wire::DiscoveredPayload<'_>>().fmt(f)
4709 },
4710 5 => unsafe {
4711 self.raw.get().deref_unchecked::<crate::wire::DestroyedPayload<'_>>().fmt(f)
4712 },
4713 6 => unsafe {
4714 self.raw.get().deref_unchecked::<crate::wire::ResolvedPayload<'_>>().fmt(f)
4715 },
4716 7 => unsafe {
4717 self.raw.get().deref_unchecked::<crate::wire::StartedPayload<'_>>().fmt(f)
4718 },
4719 8 => unsafe {
4720 self.raw.get().deref_unchecked::<crate::wire::StoppedPayload<'_>>().fmt(f)
4721 },
4722 9 => unsafe {
4723 self.raw.get().deref_unchecked::<crate::wire::DebugStartedPayload<'_>>().fmt(f)
4724 },
4725 10 => unsafe {
4726 self.raw.get().deref_unchecked::<crate::wire::UnresolvedPayload<'_>>().fmt(f)
4727 },
4728 _ => unsafe { ::core::hint::unreachable_unchecked() },
4729 }
4730 }
4731 }
4732
4733 impl<'de> ::fidl_next::IntoNatural for EventPayload<'de> {
4734 type Natural = crate::natural::EventPayload;
4735 }
4736
4737 #[repr(C)]
4739 pub struct Event<'de> {
4740 pub(crate) table: ::fidl_next::wire::Table<'de>,
4741 }
4742
4743 impl<'de> Drop for Event<'de> {
4744 fn drop(&mut self) {
4745 let _ = self.table.get(1).map(|envelope| unsafe {
4746 envelope.read_unchecked::<crate::wire::EventHeader<'de>>()
4747 });
4748
4749 let _ = self.table.get(2).map(|envelope| unsafe {
4750 envelope.read_unchecked::<crate::wire::EventPayload<'de>>()
4751 });
4752 }
4753 }
4754
4755 impl ::fidl_next::Constrained for Event<'_> {
4756 type Constraint = ();
4757
4758 fn validate(
4759 _: ::fidl_next::Slot<'_, Self>,
4760 _: Self::Constraint,
4761 ) -> Result<(), ::fidl_next::ValidationError> {
4762 Ok(())
4763 }
4764 }
4765
4766 unsafe impl ::fidl_next::Wire for Event<'static> {
4767 type Narrowed<'de> = Event<'de>;
4768
4769 #[inline]
4770 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
4771 ::fidl_next::munge!(let Self { table } = out);
4772 ::fidl_next::wire::Table::zero_padding(table);
4773 }
4774 }
4775
4776 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for Event<'de>
4777 where
4778 ___D: ::fidl_next::Decoder<'de> + ?Sized,
4779 ___D: ::fidl_next::fuchsia::HandleDecoder,
4780 {
4781 fn decode(
4782 slot: ::fidl_next::Slot<'_, Self>,
4783 decoder: &mut ___D,
4784 _: (),
4785 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4786 ::fidl_next::munge!(let Self { table } = slot);
4787
4788 ::fidl_next::wire::Table::decode_with(table, decoder, |ordinal, mut slot, decoder| {
4789 match ordinal {
4790 0 => unsafe { ::core::hint::unreachable_unchecked() },
4791
4792 1 => {
4793 ::fidl_next::wire::Envelope::decode_as::<
4794 ___D,
4795 crate::wire::EventHeader<'de>,
4796 >(slot.as_mut(), decoder, ())?;
4797
4798 Ok(())
4799 }
4800
4801 2 => {
4802 ::fidl_next::wire::Envelope::decode_as::<
4803 ___D,
4804 crate::wire::EventPayload<'de>,
4805 >(slot.as_mut(), decoder, ())?;
4806
4807 Ok(())
4808 }
4809
4810 _ => ::fidl_next::wire::Envelope::decode_unknown(slot, decoder),
4811 }
4812 })
4813 }
4814 }
4815
4816 impl<'de> Event<'de> {
4817 pub fn header(&self) -> ::core::option::Option<&crate::wire::EventHeader<'de>> {
4818 unsafe { Some(self.table.get(1)?.deref_unchecked()) }
4819 }
4820
4821 pub fn payload(&self) -> ::core::option::Option<&crate::wire::EventPayload<'de>> {
4822 unsafe { Some(self.table.get(2)?.deref_unchecked()) }
4823 }
4824 }
4825
4826 impl<'de> ::core::fmt::Debug for Event<'de> {
4827 fn fmt(
4828 &self,
4829 f: &mut ::core::fmt::Formatter<'_>,
4830 ) -> ::core::result::Result<(), ::core::fmt::Error> {
4831 f.debug_struct("Event")
4832 .field("header", &self.header())
4833 .field("payload", &self.payload())
4834 .finish()
4835 }
4836 }
4837
4838 impl<'de> ::fidl_next::IntoNatural for Event<'de> {
4839 type Natural = crate::natural::Event;
4840 }
4841
4842 #[derive(Debug)]
4844 #[repr(C)]
4845 pub struct EventStreamGetNextResponse<'de> {
4846 pub events: ::fidl_next::wire::Vector<'de, crate::wire::Event<'de>>,
4847 }
4848
4849 static_assertions::const_assert_eq!(std::mem::size_of::<EventStreamGetNextResponse<'_>>(), 16);
4850 static_assertions::const_assert_eq!(std::mem::align_of::<EventStreamGetNextResponse<'_>>(), 8);
4851
4852 static_assertions::const_assert_eq!(
4853 std::mem::offset_of!(EventStreamGetNextResponse<'_>, events),
4854 0
4855 );
4856
4857 impl ::fidl_next::Constrained for EventStreamGetNextResponse<'_> {
4858 type Constraint = ();
4859
4860 fn validate(
4861 _: ::fidl_next::Slot<'_, Self>,
4862 _: Self::Constraint,
4863 ) -> Result<(), ::fidl_next::ValidationError> {
4864 Ok(())
4865 }
4866 }
4867
4868 unsafe impl ::fidl_next::Wire for EventStreamGetNextResponse<'static> {
4869 type Narrowed<'de> = EventStreamGetNextResponse<'de>;
4870
4871 #[inline]
4872 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4873 ::fidl_next::munge! {
4874 let Self {
4875 events,
4876
4877 } = &mut *out_;
4878 }
4879
4880 ::fidl_next::Wire::zero_padding(events);
4881 }
4882 }
4883
4884 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EventStreamGetNextResponse<'de>
4885 where
4886 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4887 ___D: ::fidl_next::Decoder<'de>,
4888 ___D: ::fidl_next::fuchsia::HandleDecoder,
4889 {
4890 fn decode(
4891 slot_: ::fidl_next::Slot<'_, Self>,
4892 decoder_: &mut ___D,
4893 _: (),
4894 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4895 ::fidl_next::munge! {
4896 let Self {
4897 mut events,
4898
4899 } = slot_;
4900 }
4901
4902 let _field = events.as_mut();
4903 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
4904 ::fidl_next::Decode::decode(events.as_mut(), decoder_, (4294967295, ()))?;
4905
4906 Ok(())
4907 }
4908 }
4909
4910 impl<'de> ::fidl_next::IntoNatural for EventStreamGetNextResponse<'de> {
4911 type Natural = crate::natural::EventStreamGetNextResponse;
4912 }
4913
4914 #[derive(Debug)]
4916 #[repr(C)]
4917 pub struct IntrospectorGetMonikerRequest {
4918 pub component_instance: ::fidl_next::wire::fuchsia::Event,
4919 }
4920
4921 static_assertions::const_assert_eq!(std::mem::size_of::<IntrospectorGetMonikerRequest>(), 4);
4922 static_assertions::const_assert_eq!(std::mem::align_of::<IntrospectorGetMonikerRequest>(), 4);
4923
4924 static_assertions::const_assert_eq!(
4925 std::mem::offset_of!(IntrospectorGetMonikerRequest, component_instance),
4926 0
4927 );
4928
4929 impl ::fidl_next::Constrained for IntrospectorGetMonikerRequest {
4930 type Constraint = ();
4931
4932 fn validate(
4933 _: ::fidl_next::Slot<'_, Self>,
4934 _: Self::Constraint,
4935 ) -> Result<(), ::fidl_next::ValidationError> {
4936 Ok(())
4937 }
4938 }
4939
4940 unsafe impl ::fidl_next::Wire for IntrospectorGetMonikerRequest {
4941 type Narrowed<'de> = IntrospectorGetMonikerRequest;
4942
4943 #[inline]
4944 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
4945 ::fidl_next::munge! {
4946 let Self {
4947 component_instance,
4948
4949 } = &mut *out_;
4950 }
4951
4952 ::fidl_next::Wire::zero_padding(component_instance);
4953 }
4954 }
4955
4956 unsafe impl<___D> ::fidl_next::Decode<___D> for IntrospectorGetMonikerRequest
4957 where
4958 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
4959 ___D: ::fidl_next::fuchsia::HandleDecoder,
4960 {
4961 fn decode(
4962 slot_: ::fidl_next::Slot<'_, Self>,
4963 decoder_: &mut ___D,
4964 _: (),
4965 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
4966 ::fidl_next::munge! {
4967 let Self {
4968 mut component_instance,
4969
4970 } = slot_;
4971 }
4972
4973 let _field = component_instance.as_mut();
4974
4975 ::fidl_next::Decode::decode(component_instance.as_mut(), decoder_, ())?;
4976
4977 Ok(())
4978 }
4979 }
4980
4981 impl ::fidl_next::IntoNatural for IntrospectorGetMonikerRequest {
4982 type Natural = crate::natural::IntrospectorGetMonikerRequest;
4983 }
4984
4985 #[derive(Debug)]
4987 #[repr(C)]
4988 pub struct NamespaceInputEntry<'de> {
4989 pub path: ::fidl_next::wire::String<'de>,
4990
4991 pub dictionary: ::fidl_next::ClientEnd<
4992 ::fidl_next_fuchsia_component_sandbox::Dictionary,
4993 ::fidl_next::wire::fuchsia::Channel,
4994 >,
4995 }
4996
4997 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceInputEntry<'_>>(), 24);
4998 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceInputEntry<'_>>(), 8);
4999
5000 static_assertions::const_assert_eq!(std::mem::offset_of!(NamespaceInputEntry<'_>, path), 0);
5001
5002 static_assertions::const_assert_eq!(
5003 std::mem::offset_of!(NamespaceInputEntry<'_>, dictionary),
5004 16
5005 );
5006
5007 impl ::fidl_next::Constrained for NamespaceInputEntry<'_> {
5008 type Constraint = ();
5009
5010 fn validate(
5011 _: ::fidl_next::Slot<'_, Self>,
5012 _: Self::Constraint,
5013 ) -> Result<(), ::fidl_next::ValidationError> {
5014 Ok(())
5015 }
5016 }
5017
5018 unsafe impl ::fidl_next::Wire for NamespaceInputEntry<'static> {
5019 type Narrowed<'de> = NamespaceInputEntry<'de>;
5020
5021 #[inline]
5022 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5023 ::fidl_next::munge! {
5024 let Self {
5025 path,
5026 dictionary,
5027
5028 } = &mut *out_;
5029 }
5030
5031 ::fidl_next::Wire::zero_padding(path);
5032
5033 ::fidl_next::Wire::zero_padding(dictionary);
5034
5035 unsafe {
5036 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
5037 }
5038 }
5039 }
5040
5041 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceInputEntry<'de>
5042 where
5043 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5044 ___D: ::fidl_next::Decoder<'de>,
5045 ___D: ::fidl_next::fuchsia::HandleDecoder,
5046 {
5047 fn decode(
5048 slot_: ::fidl_next::Slot<'_, Self>,
5049 decoder_: &mut ___D,
5050 _: (),
5051 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5052 if slot_.as_bytes()[20..24] != [0u8; 4] {
5053 return Err(::fidl_next::DecodeError::InvalidPadding);
5054 }
5055
5056 ::fidl_next::munge! {
5057 let Self {
5058 mut path,
5059 mut dictionary,
5060
5061 } = slot_;
5062 }
5063
5064 let _field = path.as_mut();
5065 ::fidl_next::Constrained::validate(_field, 4095)?;
5066 ::fidl_next::Decode::decode(path.as_mut(), decoder_, 4095)?;
5067
5068 let path = unsafe { path.deref_unchecked() };
5069
5070 if path.len() > 4095 {
5071 return Err(::fidl_next::DecodeError::VectorTooLong {
5072 size: path.len() as u64,
5073 limit: 4095,
5074 });
5075 }
5076
5077 let _field = dictionary.as_mut();
5078
5079 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
5080
5081 Ok(())
5082 }
5083 }
5084
5085 impl<'de> ::fidl_next::IntoNatural for NamespaceInputEntry<'de> {
5086 type Natural = crate::natural::NamespaceInputEntry;
5087 }
5088
5089 #[derive(Debug)]
5091 #[repr(C)]
5092 pub struct NamespaceCreateRequest<'de> {
5093 pub entries: ::fidl_next::wire::Vector<'de, crate::wire::NamespaceInputEntry<'de>>,
5094 }
5095
5096 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceCreateRequest<'_>>(), 16);
5097 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceCreateRequest<'_>>(), 8);
5098
5099 static_assertions::const_assert_eq!(
5100 std::mem::offset_of!(NamespaceCreateRequest<'_>, entries),
5101 0
5102 );
5103
5104 impl ::fidl_next::Constrained for NamespaceCreateRequest<'_> {
5105 type Constraint = ();
5106
5107 fn validate(
5108 _: ::fidl_next::Slot<'_, Self>,
5109 _: Self::Constraint,
5110 ) -> Result<(), ::fidl_next::ValidationError> {
5111 Ok(())
5112 }
5113 }
5114
5115 unsafe impl ::fidl_next::Wire for NamespaceCreateRequest<'static> {
5116 type Narrowed<'de> = NamespaceCreateRequest<'de>;
5117
5118 #[inline]
5119 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5120 ::fidl_next::munge! {
5121 let Self {
5122 entries,
5123
5124 } = &mut *out_;
5125 }
5126
5127 ::fidl_next::Wire::zero_padding(entries);
5128 }
5129 }
5130
5131 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceCreateRequest<'de>
5132 where
5133 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5134 ___D: ::fidl_next::Decoder<'de>,
5135 ___D: ::fidl_next::fuchsia::HandleDecoder,
5136 {
5137 fn decode(
5138 slot_: ::fidl_next::Slot<'_, Self>,
5139 decoder_: &mut ___D,
5140 _: (),
5141 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5142 ::fidl_next::munge! {
5143 let Self {
5144 mut entries,
5145
5146 } = slot_;
5147 }
5148
5149 let _field = entries.as_mut();
5150 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5151 ::fidl_next::Decode::decode(entries.as_mut(), decoder_, (4294967295, ()))?;
5152
5153 Ok(())
5154 }
5155 }
5156
5157 impl<'de> ::fidl_next::IntoNatural for NamespaceCreateRequest<'de> {
5158 type Natural = crate::natural::NamespaceCreateRequest;
5159 }
5160
5161 #[derive(Debug)]
5163 #[repr(C)]
5164 pub struct NamespaceInputEntry2<'de> {
5165 pub path: ::fidl_next::wire::String<'de>,
5166
5167 pub capability: ::fidl_next::wire::fuchsia::EventPair,
5168 }
5169
5170 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceInputEntry2<'_>>(), 24);
5171 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceInputEntry2<'_>>(), 8);
5172
5173 static_assertions::const_assert_eq!(std::mem::offset_of!(NamespaceInputEntry2<'_>, path), 0);
5174
5175 static_assertions::const_assert_eq!(
5176 std::mem::offset_of!(NamespaceInputEntry2<'_>, capability),
5177 16
5178 );
5179
5180 impl ::fidl_next::Constrained for NamespaceInputEntry2<'_> {
5181 type Constraint = ();
5182
5183 fn validate(
5184 _: ::fidl_next::Slot<'_, Self>,
5185 _: Self::Constraint,
5186 ) -> Result<(), ::fidl_next::ValidationError> {
5187 Ok(())
5188 }
5189 }
5190
5191 unsafe impl ::fidl_next::Wire for NamespaceInputEntry2<'static> {
5192 type Narrowed<'de> = NamespaceInputEntry2<'de>;
5193
5194 #[inline]
5195 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5196 ::fidl_next::munge! {
5197 let Self {
5198 path,
5199 capability,
5200
5201 } = &mut *out_;
5202 }
5203
5204 ::fidl_next::Wire::zero_padding(path);
5205
5206 ::fidl_next::Wire::zero_padding(capability);
5207
5208 unsafe {
5209 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
5210 }
5211 }
5212 }
5213
5214 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceInputEntry2<'de>
5215 where
5216 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5217 ___D: ::fidl_next::Decoder<'de>,
5218 ___D: ::fidl_next::fuchsia::HandleDecoder,
5219 {
5220 fn decode(
5221 slot_: ::fidl_next::Slot<'_, Self>,
5222 decoder_: &mut ___D,
5223 _: (),
5224 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5225 if slot_.as_bytes()[20..24] != [0u8; 4] {
5226 return Err(::fidl_next::DecodeError::InvalidPadding);
5227 }
5228
5229 ::fidl_next::munge! {
5230 let Self {
5231 mut path,
5232 mut capability,
5233
5234 } = slot_;
5235 }
5236
5237 let _field = path.as_mut();
5238 ::fidl_next::Constrained::validate(_field, 4095)?;
5239 ::fidl_next::Decode::decode(path.as_mut(), decoder_, 4095)?;
5240
5241 let path = unsafe { path.deref_unchecked() };
5242
5243 if path.len() > 4095 {
5244 return Err(::fidl_next::DecodeError::VectorTooLong {
5245 size: path.len() as u64,
5246 limit: 4095,
5247 });
5248 }
5249
5250 let _field = capability.as_mut();
5251
5252 ::fidl_next::Decode::decode(capability.as_mut(), decoder_, ())?;
5253
5254 Ok(())
5255 }
5256 }
5257
5258 impl<'de> ::fidl_next::IntoNatural for NamespaceInputEntry2<'de> {
5259 type Natural = crate::natural::NamespaceInputEntry2;
5260 }
5261
5262 #[derive(Debug)]
5264 #[repr(C)]
5265 pub struct NamespaceCreate2Request<'de> {
5266 pub entries: ::fidl_next::wire::Vector<'de, crate::wire::NamespaceInputEntry2<'de>>,
5267 }
5268
5269 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceCreate2Request<'_>>(), 16);
5270 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceCreate2Request<'_>>(), 8);
5271
5272 static_assertions::const_assert_eq!(
5273 std::mem::offset_of!(NamespaceCreate2Request<'_>, entries),
5274 0
5275 );
5276
5277 impl ::fidl_next::Constrained for NamespaceCreate2Request<'_> {
5278 type Constraint = ();
5279
5280 fn validate(
5281 _: ::fidl_next::Slot<'_, Self>,
5282 _: Self::Constraint,
5283 ) -> Result<(), ::fidl_next::ValidationError> {
5284 Ok(())
5285 }
5286 }
5287
5288 unsafe impl ::fidl_next::Wire for NamespaceCreate2Request<'static> {
5289 type Narrowed<'de> = NamespaceCreate2Request<'de>;
5290
5291 #[inline]
5292 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5293 ::fidl_next::munge! {
5294 let Self {
5295 entries,
5296
5297 } = &mut *out_;
5298 }
5299
5300 ::fidl_next::Wire::zero_padding(entries);
5301 }
5302 }
5303
5304 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceCreate2Request<'de>
5305 where
5306 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5307 ___D: ::fidl_next::Decoder<'de>,
5308 ___D: ::fidl_next::fuchsia::HandleDecoder,
5309 {
5310 fn decode(
5311 slot_: ::fidl_next::Slot<'_, Self>,
5312 decoder_: &mut ___D,
5313 _: (),
5314 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5315 ::fidl_next::munge! {
5316 let Self {
5317 mut entries,
5318
5319 } = slot_;
5320 }
5321
5322 let _field = entries.as_mut();
5323 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5324 ::fidl_next::Decode::decode(entries.as_mut(), decoder_, (4294967295, ()))?;
5325
5326 Ok(())
5327 }
5328 }
5329
5330 impl<'de> ::fidl_next::IntoNatural for NamespaceCreate2Request<'de> {
5331 type Natural = crate::natural::NamespaceCreate2Request;
5332 }
5333
5334 #[derive(Debug)]
5336 #[repr(C)]
5337 pub struct NamespaceCreateResponse<'de> {
5338 pub entries: ::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>,
5339 }
5340
5341 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceCreateResponse<'_>>(), 16);
5342 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceCreateResponse<'_>>(), 8);
5343
5344 static_assertions::const_assert_eq!(
5345 std::mem::offset_of!(NamespaceCreateResponse<'_>, entries),
5346 0
5347 );
5348
5349 impl ::fidl_next::Constrained for NamespaceCreateResponse<'_> {
5350 type Constraint = ();
5351
5352 fn validate(
5353 _: ::fidl_next::Slot<'_, Self>,
5354 _: Self::Constraint,
5355 ) -> Result<(), ::fidl_next::ValidationError> {
5356 Ok(())
5357 }
5358 }
5359
5360 unsafe impl ::fidl_next::Wire for NamespaceCreateResponse<'static> {
5361 type Narrowed<'de> = NamespaceCreateResponse<'de>;
5362
5363 #[inline]
5364 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5365 ::fidl_next::munge! {
5366 let Self {
5367 entries,
5368
5369 } = &mut *out_;
5370 }
5371
5372 ::fidl_next::Wire::zero_padding(entries);
5373 }
5374 }
5375
5376 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceCreateResponse<'de>
5377 where
5378 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5379 ___D: ::fidl_next::Decoder<'de>,
5380 ___D: ::fidl_next::fuchsia::HandleDecoder,
5381 {
5382 fn decode(
5383 slot_: ::fidl_next::Slot<'_, Self>,
5384 decoder_: &mut ___D,
5385 _: (),
5386 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5387 ::fidl_next::munge! {
5388 let Self {
5389 mut entries,
5390
5391 } = slot_;
5392 }
5393
5394 let _field = entries.as_mut();
5395 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5396 ::fidl_next::Decode::decode(entries.as_mut(), decoder_, (4294967295, ()))?;
5397
5398 Ok(())
5399 }
5400 }
5401
5402 impl<'de> ::fidl_next::IntoNatural for NamespaceCreateResponse<'de> {
5403 type Natural = crate::natural::NamespaceCreateResponse;
5404 }
5405
5406 #[derive(Debug)]
5408 #[repr(C)]
5409 pub struct NamespaceCreate2Response<'de> {
5410 pub entries: ::fidl_next::wire::Vector<'de, crate::wire::NamespaceEntry<'de>>,
5411 }
5412
5413 static_assertions::const_assert_eq!(std::mem::size_of::<NamespaceCreate2Response<'_>>(), 16);
5414 static_assertions::const_assert_eq!(std::mem::align_of::<NamespaceCreate2Response<'_>>(), 8);
5415
5416 static_assertions::const_assert_eq!(
5417 std::mem::offset_of!(NamespaceCreate2Response<'_>, entries),
5418 0
5419 );
5420
5421 impl ::fidl_next::Constrained for NamespaceCreate2Response<'_> {
5422 type Constraint = ();
5423
5424 fn validate(
5425 _: ::fidl_next::Slot<'_, Self>,
5426 _: Self::Constraint,
5427 ) -> Result<(), ::fidl_next::ValidationError> {
5428 Ok(())
5429 }
5430 }
5431
5432 unsafe impl ::fidl_next::Wire for NamespaceCreate2Response<'static> {
5433 type Narrowed<'de> = NamespaceCreate2Response<'de>;
5434
5435 #[inline]
5436 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5437 ::fidl_next::munge! {
5438 let Self {
5439 entries,
5440
5441 } = &mut *out_;
5442 }
5443
5444 ::fidl_next::Wire::zero_padding(entries);
5445 }
5446 }
5447
5448 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for NamespaceCreate2Response<'de>
5449 where
5450 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5451 ___D: ::fidl_next::Decoder<'de>,
5452 ___D: ::fidl_next::fuchsia::HandleDecoder,
5453 {
5454 fn decode(
5455 slot_: ::fidl_next::Slot<'_, Self>,
5456 decoder_: &mut ___D,
5457 _: (),
5458 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5459 ::fidl_next::munge! {
5460 let Self {
5461 mut entries,
5462
5463 } = slot_;
5464 }
5465
5466 let _field = entries.as_mut();
5467 ::fidl_next::Constrained::validate(_field, (4294967295, ()))?;
5468 ::fidl_next::Decode::decode(entries.as_mut(), decoder_, (4294967295, ()))?;
5469
5470 Ok(())
5471 }
5472 }
5473
5474 impl<'de> ::fidl_next::IntoNatural for NamespaceCreate2Response<'de> {
5475 type Natural = crate::natural::NamespaceCreate2Response;
5476 }
5477
5478 #[derive(Debug)]
5480 #[repr(C)]
5481 pub struct RealmListChildrenRequest<'de> {
5482 pub collection: ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'de>,
5483
5484 pub iter: ::fidl_next::ServerEnd<crate::ChildIterator, ::fidl_next::wire::fuchsia::Channel>,
5485 }
5486
5487 static_assertions::const_assert_eq!(std::mem::size_of::<RealmListChildrenRequest<'_>>(), 24);
5488 static_assertions::const_assert_eq!(std::mem::align_of::<RealmListChildrenRequest<'_>>(), 8);
5489
5490 static_assertions::const_assert_eq!(
5491 std::mem::offset_of!(RealmListChildrenRequest<'_>, collection),
5492 0
5493 );
5494
5495 static_assertions::const_assert_eq!(
5496 std::mem::offset_of!(RealmListChildrenRequest<'_>, iter),
5497 16
5498 );
5499
5500 impl ::fidl_next::Constrained for RealmListChildrenRequest<'_> {
5501 type Constraint = ();
5502
5503 fn validate(
5504 _: ::fidl_next::Slot<'_, Self>,
5505 _: Self::Constraint,
5506 ) -> Result<(), ::fidl_next::ValidationError> {
5507 Ok(())
5508 }
5509 }
5510
5511 unsafe impl ::fidl_next::Wire for RealmListChildrenRequest<'static> {
5512 type Narrowed<'de> = RealmListChildrenRequest<'de>;
5513
5514 #[inline]
5515 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5516 ::fidl_next::munge! {
5517 let Self {
5518 collection,
5519 iter,
5520
5521 } = &mut *out_;
5522 }
5523
5524 ::fidl_next::Wire::zero_padding(collection);
5525
5526 ::fidl_next::Wire::zero_padding(iter);
5527
5528 unsafe {
5529 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
5530 }
5531 }
5532 }
5533
5534 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmListChildrenRequest<'de>
5535 where
5536 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5537 ___D: ::fidl_next::Decoder<'de>,
5538 ___D: ::fidl_next::fuchsia::HandleDecoder,
5539 {
5540 fn decode(
5541 slot_: ::fidl_next::Slot<'_, Self>,
5542 decoder_: &mut ___D,
5543 _: (),
5544 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5545 if slot_.as_bytes()[20..24] != [0u8; 4] {
5546 return Err(::fidl_next::DecodeError::InvalidPadding);
5547 }
5548
5549 ::fidl_next::munge! {
5550 let Self {
5551 mut collection,
5552 mut iter,
5553
5554 } = slot_;
5555 }
5556
5557 let _field = collection.as_mut();
5558
5559 ::fidl_next::Decode::decode(collection.as_mut(), decoder_, ())?;
5560
5561 let _field = iter.as_mut();
5562
5563 ::fidl_next::Decode::decode(iter.as_mut(), decoder_, ())?;
5564
5565 Ok(())
5566 }
5567 }
5568
5569 impl<'de> ::fidl_next::IntoNatural for RealmListChildrenRequest<'de> {
5570 type Natural = crate::natural::RealmListChildrenRequest;
5571 }
5572
5573 #[derive(Debug)]
5575 #[repr(C)]
5576 pub struct RealmGetChildOutputDictionaryDeprecatedRequest<'de> {
5577 pub child: ::fidl_next_fuchsia_component_decl::wire::ChildRef<'de>,
5578 }
5579
5580 static_assertions::const_assert_eq!(
5581 std::mem::size_of::<RealmGetChildOutputDictionaryDeprecatedRequest<'_>>(),
5582 32
5583 );
5584 static_assertions::const_assert_eq!(
5585 std::mem::align_of::<RealmGetChildOutputDictionaryDeprecatedRequest<'_>>(),
5586 8
5587 );
5588
5589 static_assertions::const_assert_eq!(
5590 std::mem::offset_of!(RealmGetChildOutputDictionaryDeprecatedRequest<'_>, child),
5591 0
5592 );
5593
5594 impl ::fidl_next::Constrained for RealmGetChildOutputDictionaryDeprecatedRequest<'_> {
5595 type Constraint = ();
5596
5597 fn validate(
5598 _: ::fidl_next::Slot<'_, Self>,
5599 _: Self::Constraint,
5600 ) -> Result<(), ::fidl_next::ValidationError> {
5601 Ok(())
5602 }
5603 }
5604
5605 unsafe impl ::fidl_next::Wire for RealmGetChildOutputDictionaryDeprecatedRequest<'static> {
5606 type Narrowed<'de> = RealmGetChildOutputDictionaryDeprecatedRequest<'de>;
5607
5608 #[inline]
5609 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5610 ::fidl_next::munge! {
5611 let Self {
5612 child,
5613
5614 } = &mut *out_;
5615 }
5616
5617 ::fidl_next::Wire::zero_padding(child);
5618 }
5619 }
5620
5621 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
5622 for RealmGetChildOutputDictionaryDeprecatedRequest<'de>
5623 where
5624 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5625 ___D: ::fidl_next::Decoder<'de>,
5626 ___D: ::fidl_next::fuchsia::HandleDecoder,
5627 {
5628 fn decode(
5629 slot_: ::fidl_next::Slot<'_, Self>,
5630 decoder_: &mut ___D,
5631 _: (),
5632 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5633 ::fidl_next::munge! {
5634 let Self {
5635 mut child,
5636
5637 } = slot_;
5638 }
5639
5640 let _field = child.as_mut();
5641
5642 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
5643
5644 Ok(())
5645 }
5646 }
5647
5648 impl<'de> ::fidl_next::IntoNatural for RealmGetChildOutputDictionaryDeprecatedRequest<'de> {
5649 type Natural = crate::natural::RealmGetChildOutputDictionaryDeprecatedRequest;
5650 }
5651
5652 #[derive(Debug)]
5654 #[repr(C)]
5655 pub struct RealmGetChildOutputDictionaryDeprecatedResponse {
5656 pub dictionary: ::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef,
5657 }
5658
5659 static_assertions::const_assert_eq!(
5660 std::mem::size_of::<RealmGetChildOutputDictionaryDeprecatedResponse>(),
5661 4
5662 );
5663 static_assertions::const_assert_eq!(
5664 std::mem::align_of::<RealmGetChildOutputDictionaryDeprecatedResponse>(),
5665 4
5666 );
5667
5668 static_assertions::const_assert_eq!(
5669 std::mem::offset_of!(RealmGetChildOutputDictionaryDeprecatedResponse, dictionary),
5670 0
5671 );
5672
5673 impl ::fidl_next::Constrained for RealmGetChildOutputDictionaryDeprecatedResponse {
5674 type Constraint = ();
5675
5676 fn validate(
5677 _: ::fidl_next::Slot<'_, Self>,
5678 _: Self::Constraint,
5679 ) -> Result<(), ::fidl_next::ValidationError> {
5680 Ok(())
5681 }
5682 }
5683
5684 unsafe impl ::fidl_next::Wire for RealmGetChildOutputDictionaryDeprecatedResponse {
5685 type Narrowed<'de> = RealmGetChildOutputDictionaryDeprecatedResponse;
5686
5687 #[inline]
5688 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5689 ::fidl_next::munge! {
5690 let Self {
5691 dictionary,
5692
5693 } = &mut *out_;
5694 }
5695
5696 ::fidl_next::Wire::zero_padding(dictionary);
5697 }
5698 }
5699
5700 unsafe impl<___D> ::fidl_next::Decode<___D> for RealmGetChildOutputDictionaryDeprecatedResponse
5701 where
5702 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5703 ___D: ::fidl_next::fuchsia::HandleDecoder,
5704 {
5705 fn decode(
5706 slot_: ::fidl_next::Slot<'_, Self>,
5707 decoder_: &mut ___D,
5708 _: (),
5709 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5710 ::fidl_next::munge! {
5711 let Self {
5712 mut dictionary,
5713
5714 } = slot_;
5715 }
5716
5717 let _field = dictionary.as_mut();
5718
5719 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
5720
5721 Ok(())
5722 }
5723 }
5724
5725 impl ::fidl_next::IntoNatural for RealmGetChildOutputDictionaryDeprecatedResponse {
5726 type Natural = crate::natural::RealmGetChildOutputDictionaryDeprecatedResponse;
5727 }
5728
5729 #[derive(Debug)]
5731 #[repr(C)]
5732 pub struct RealmGetChildOutputDictionaryRequest<'de> {
5733 pub child: ::fidl_next_fuchsia_component_decl::wire::ChildRef<'de>,
5734 }
5735
5736 static_assertions::const_assert_eq!(
5737 std::mem::size_of::<RealmGetChildOutputDictionaryRequest<'_>>(),
5738 32
5739 );
5740 static_assertions::const_assert_eq!(
5741 std::mem::align_of::<RealmGetChildOutputDictionaryRequest<'_>>(),
5742 8
5743 );
5744
5745 static_assertions::const_assert_eq!(
5746 std::mem::offset_of!(RealmGetChildOutputDictionaryRequest<'_>, child),
5747 0
5748 );
5749
5750 impl ::fidl_next::Constrained for RealmGetChildOutputDictionaryRequest<'_> {
5751 type Constraint = ();
5752
5753 fn validate(
5754 _: ::fidl_next::Slot<'_, Self>,
5755 _: Self::Constraint,
5756 ) -> Result<(), ::fidl_next::ValidationError> {
5757 Ok(())
5758 }
5759 }
5760
5761 unsafe impl ::fidl_next::Wire for RealmGetChildOutputDictionaryRequest<'static> {
5762 type Narrowed<'de> = RealmGetChildOutputDictionaryRequest<'de>;
5763
5764 #[inline]
5765 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5766 ::fidl_next::munge! {
5767 let Self {
5768 child,
5769
5770 } = &mut *out_;
5771 }
5772
5773 ::fidl_next::Wire::zero_padding(child);
5774 }
5775 }
5776
5777 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmGetChildOutputDictionaryRequest<'de>
5778 where
5779 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5780 ___D: ::fidl_next::Decoder<'de>,
5781 ___D: ::fidl_next::fuchsia::HandleDecoder,
5782 {
5783 fn decode(
5784 slot_: ::fidl_next::Slot<'_, Self>,
5785 decoder_: &mut ___D,
5786 _: (),
5787 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5788 ::fidl_next::munge! {
5789 let Self {
5790 mut child,
5791
5792 } = slot_;
5793 }
5794
5795 let _field = child.as_mut();
5796
5797 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
5798
5799 Ok(())
5800 }
5801 }
5802
5803 impl<'de> ::fidl_next::IntoNatural for RealmGetChildOutputDictionaryRequest<'de> {
5804 type Natural = crate::natural::RealmGetChildOutputDictionaryRequest;
5805 }
5806
5807 #[derive(Debug)]
5809 #[repr(C)]
5810 pub struct RealmGetChildOutputDictionaryResponse {
5811 pub dictionary: ::fidl_next::wire::fuchsia::EventPair,
5812 }
5813
5814 static_assertions::const_assert_eq!(
5815 std::mem::size_of::<RealmGetChildOutputDictionaryResponse>(),
5816 4
5817 );
5818 static_assertions::const_assert_eq!(
5819 std::mem::align_of::<RealmGetChildOutputDictionaryResponse>(),
5820 4
5821 );
5822
5823 static_assertions::const_assert_eq!(
5824 std::mem::offset_of!(RealmGetChildOutputDictionaryResponse, dictionary),
5825 0
5826 );
5827
5828 impl ::fidl_next::Constrained for RealmGetChildOutputDictionaryResponse {
5829 type Constraint = ();
5830
5831 fn validate(
5832 _: ::fidl_next::Slot<'_, Self>,
5833 _: Self::Constraint,
5834 ) -> Result<(), ::fidl_next::ValidationError> {
5835 Ok(())
5836 }
5837 }
5838
5839 unsafe impl ::fidl_next::Wire for RealmGetChildOutputDictionaryResponse {
5840 type Narrowed<'de> = RealmGetChildOutputDictionaryResponse;
5841
5842 #[inline]
5843 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5844 ::fidl_next::munge! {
5845 let Self {
5846 dictionary,
5847
5848 } = &mut *out_;
5849 }
5850
5851 ::fidl_next::Wire::zero_padding(dictionary);
5852 }
5853 }
5854
5855 unsafe impl<___D> ::fidl_next::Decode<___D> for RealmGetChildOutputDictionaryResponse
5856 where
5857 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5858 ___D: ::fidl_next::fuchsia::HandleDecoder,
5859 {
5860 fn decode(
5861 slot_: ::fidl_next::Slot<'_, Self>,
5862 decoder_: &mut ___D,
5863 _: (),
5864 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5865 ::fidl_next::munge! {
5866 let Self {
5867 mut dictionary,
5868
5869 } = slot_;
5870 }
5871
5872 let _field = dictionary.as_mut();
5873
5874 ::fidl_next::Decode::decode(dictionary.as_mut(), decoder_, ())?;
5875
5876 Ok(())
5877 }
5878 }
5879
5880 impl ::fidl_next::IntoNatural for RealmGetChildOutputDictionaryResponse {
5881 type Natural = crate::natural::RealmGetChildOutputDictionaryResponse;
5882 }
5883
5884 #[derive(Debug)]
5886 #[repr(C)]
5887 pub struct RealmOpenControllerRequest<'de> {
5888 pub child: ::fidl_next_fuchsia_component_decl::wire::ChildRef<'de>,
5889
5890 pub controller:
5891 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
5892 }
5893
5894 static_assertions::const_assert_eq!(std::mem::size_of::<RealmOpenControllerRequest<'_>>(), 40);
5895 static_assertions::const_assert_eq!(std::mem::align_of::<RealmOpenControllerRequest<'_>>(), 8);
5896
5897 static_assertions::const_assert_eq!(
5898 std::mem::offset_of!(RealmOpenControllerRequest<'_>, child),
5899 0
5900 );
5901
5902 static_assertions::const_assert_eq!(
5903 std::mem::offset_of!(RealmOpenControllerRequest<'_>, controller),
5904 32
5905 );
5906
5907 impl ::fidl_next::Constrained for RealmOpenControllerRequest<'_> {
5908 type Constraint = ();
5909
5910 fn validate(
5911 _: ::fidl_next::Slot<'_, Self>,
5912 _: Self::Constraint,
5913 ) -> Result<(), ::fidl_next::ValidationError> {
5914 Ok(())
5915 }
5916 }
5917
5918 unsafe impl ::fidl_next::Wire for RealmOpenControllerRequest<'static> {
5919 type Narrowed<'de> = RealmOpenControllerRequest<'de>;
5920
5921 #[inline]
5922 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
5923 ::fidl_next::munge! {
5924 let Self {
5925 child,
5926 controller,
5927
5928 } = &mut *out_;
5929 }
5930
5931 ::fidl_next::Wire::zero_padding(child);
5932
5933 ::fidl_next::Wire::zero_padding(controller);
5934
5935 unsafe {
5936 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
5937 }
5938 }
5939 }
5940
5941 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmOpenControllerRequest<'de>
5942 where
5943 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
5944 ___D: ::fidl_next::Decoder<'de>,
5945 ___D: ::fidl_next::fuchsia::HandleDecoder,
5946 {
5947 fn decode(
5948 slot_: ::fidl_next::Slot<'_, Self>,
5949 decoder_: &mut ___D,
5950 _: (),
5951 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
5952 if slot_.as_bytes()[36..40] != [0u8; 4] {
5953 return Err(::fidl_next::DecodeError::InvalidPadding);
5954 }
5955
5956 ::fidl_next::munge! {
5957 let Self {
5958 mut child,
5959 mut controller,
5960
5961 } = slot_;
5962 }
5963
5964 let _field = child.as_mut();
5965
5966 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
5967
5968 let _field = controller.as_mut();
5969
5970 ::fidl_next::Decode::decode(controller.as_mut(), decoder_, ())?;
5971
5972 Ok(())
5973 }
5974 }
5975
5976 impl<'de> ::fidl_next::IntoNatural for RealmOpenControllerRequest<'de> {
5977 type Natural = crate::natural::RealmOpenControllerRequest;
5978 }
5979
5980 #[derive(Debug)]
5982 #[repr(C)]
5983 pub struct RealmOpenExposedDirRequest<'de> {
5984 pub child: ::fidl_next_fuchsia_component_decl::wire::ChildRef<'de>,
5985
5986 pub exposed_dir: ::fidl_next::ServerEnd<
5987 ::fidl_next_fuchsia_io::Directory,
5988 ::fidl_next::wire::fuchsia::Channel,
5989 >,
5990 }
5991
5992 static_assertions::const_assert_eq!(std::mem::size_of::<RealmOpenExposedDirRequest<'_>>(), 40);
5993 static_assertions::const_assert_eq!(std::mem::align_of::<RealmOpenExposedDirRequest<'_>>(), 8);
5994
5995 static_assertions::const_assert_eq!(
5996 std::mem::offset_of!(RealmOpenExposedDirRequest<'_>, child),
5997 0
5998 );
5999
6000 static_assertions::const_assert_eq!(
6001 std::mem::offset_of!(RealmOpenExposedDirRequest<'_>, exposed_dir),
6002 32
6003 );
6004
6005 impl ::fidl_next::Constrained for RealmOpenExposedDirRequest<'_> {
6006 type Constraint = ();
6007
6008 fn validate(
6009 _: ::fidl_next::Slot<'_, Self>,
6010 _: Self::Constraint,
6011 ) -> Result<(), ::fidl_next::ValidationError> {
6012 Ok(())
6013 }
6014 }
6015
6016 unsafe impl ::fidl_next::Wire for RealmOpenExposedDirRequest<'static> {
6017 type Narrowed<'de> = RealmOpenExposedDirRequest<'de>;
6018
6019 #[inline]
6020 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6021 ::fidl_next::munge! {
6022 let Self {
6023 child,
6024 exposed_dir,
6025
6026 } = &mut *out_;
6027 }
6028
6029 ::fidl_next::Wire::zero_padding(child);
6030
6031 ::fidl_next::Wire::zero_padding(exposed_dir);
6032
6033 unsafe {
6034 out_.as_mut_ptr().cast::<u8>().add(36).write_bytes(0, 4);
6035 }
6036 }
6037 }
6038
6039 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmOpenExposedDirRequest<'de>
6040 where
6041 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6042 ___D: ::fidl_next::Decoder<'de>,
6043 ___D: ::fidl_next::fuchsia::HandleDecoder,
6044 {
6045 fn decode(
6046 slot_: ::fidl_next::Slot<'_, Self>,
6047 decoder_: &mut ___D,
6048 _: (),
6049 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6050 if slot_.as_bytes()[36..40] != [0u8; 4] {
6051 return Err(::fidl_next::DecodeError::InvalidPadding);
6052 }
6053
6054 ::fidl_next::munge! {
6055 let Self {
6056 mut child,
6057 mut exposed_dir,
6058
6059 } = slot_;
6060 }
6061
6062 let _field = child.as_mut();
6063
6064 ::fidl_next::Decode::decode(child.as_mut(), decoder_, ())?;
6065
6066 let _field = exposed_dir.as_mut();
6067
6068 ::fidl_next::Decode::decode(exposed_dir.as_mut(), decoder_, ())?;
6069
6070 Ok(())
6071 }
6072 }
6073
6074 impl<'de> ::fidl_next::IntoNatural for RealmOpenExposedDirRequest<'de> {
6075 type Natural = crate::natural::RealmOpenExposedDirRequest;
6076 }
6077
6078 #[derive(Debug)]
6080 #[repr(C)]
6081 pub struct RealmCreateChildRequest<'de> {
6082 pub collection: ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'de>,
6083
6084 pub decl: ::fidl_next_fuchsia_component_decl::wire::Child<'de>,
6085
6086 pub args: crate::wire::CreateChildArgs<'de>,
6087 }
6088
6089 static_assertions::const_assert_eq!(std::mem::size_of::<RealmCreateChildRequest<'_>>(), 48);
6090 static_assertions::const_assert_eq!(std::mem::align_of::<RealmCreateChildRequest<'_>>(), 8);
6091
6092 static_assertions::const_assert_eq!(
6093 std::mem::offset_of!(RealmCreateChildRequest<'_>, collection),
6094 0
6095 );
6096
6097 static_assertions::const_assert_eq!(
6098 std::mem::offset_of!(RealmCreateChildRequest<'_>, decl),
6099 16
6100 );
6101
6102 static_assertions::const_assert_eq!(
6103 std::mem::offset_of!(RealmCreateChildRequest<'_>, args),
6104 32
6105 );
6106
6107 impl ::fidl_next::Constrained for RealmCreateChildRequest<'_> {
6108 type Constraint = ();
6109
6110 fn validate(
6111 _: ::fidl_next::Slot<'_, Self>,
6112 _: Self::Constraint,
6113 ) -> Result<(), ::fidl_next::ValidationError> {
6114 Ok(())
6115 }
6116 }
6117
6118 unsafe impl ::fidl_next::Wire for RealmCreateChildRequest<'static> {
6119 type Narrowed<'de> = RealmCreateChildRequest<'de>;
6120
6121 #[inline]
6122 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6123 ::fidl_next::munge! {
6124 let Self {
6125 collection,
6126 decl,
6127 args,
6128
6129 } = &mut *out_;
6130 }
6131
6132 ::fidl_next::Wire::zero_padding(collection);
6133
6134 ::fidl_next::Wire::zero_padding(decl);
6135
6136 ::fidl_next::Wire::zero_padding(args);
6137 }
6138 }
6139
6140 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmCreateChildRequest<'de>
6141 where
6142 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6143 ___D: ::fidl_next::Decoder<'de>,
6144 ___D: ::fidl_next::fuchsia::HandleDecoder,
6145 {
6146 fn decode(
6147 slot_: ::fidl_next::Slot<'_, Self>,
6148 decoder_: &mut ___D,
6149 _: (),
6150 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6151 ::fidl_next::munge! {
6152 let Self {
6153 mut collection,
6154 mut decl,
6155 mut args,
6156
6157 } = slot_;
6158 }
6159
6160 let _field = collection.as_mut();
6161
6162 ::fidl_next::Decode::decode(collection.as_mut(), decoder_, ())?;
6163
6164 let _field = decl.as_mut();
6165
6166 ::fidl_next::Decode::decode(decl.as_mut(), decoder_, ())?;
6167
6168 let _field = args.as_mut();
6169
6170 ::fidl_next::Decode::decode(args.as_mut(), decoder_, ())?;
6171
6172 Ok(())
6173 }
6174 }
6175
6176 impl<'de> ::fidl_next::IntoNatural for RealmCreateChildRequest<'de> {
6177 type Natural = crate::natural::RealmCreateChildRequest;
6178 }
6179
6180 #[derive(Debug)]
6182 #[repr(C)]
6183 pub struct RealmGetResolvedInfoResponse<'de> {
6184 pub resolved_info: ::fidl_next_fuchsia_component_resolution::wire::Component<'de>,
6185 }
6186
6187 static_assertions::const_assert_eq!(
6188 std::mem::size_of::<RealmGetResolvedInfoResponse<'_>>(),
6189 16
6190 );
6191 static_assertions::const_assert_eq!(
6192 std::mem::align_of::<RealmGetResolvedInfoResponse<'_>>(),
6193 8
6194 );
6195
6196 static_assertions::const_assert_eq!(
6197 std::mem::offset_of!(RealmGetResolvedInfoResponse<'_>, resolved_info),
6198 0
6199 );
6200
6201 impl ::fidl_next::Constrained for RealmGetResolvedInfoResponse<'_> {
6202 type Constraint = ();
6203
6204 fn validate(
6205 _: ::fidl_next::Slot<'_, Self>,
6206 _: Self::Constraint,
6207 ) -> Result<(), ::fidl_next::ValidationError> {
6208 Ok(())
6209 }
6210 }
6211
6212 unsafe impl ::fidl_next::Wire for RealmGetResolvedInfoResponse<'static> {
6213 type Narrowed<'de> = RealmGetResolvedInfoResponse<'de>;
6214
6215 #[inline]
6216 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6217 ::fidl_next::munge! {
6218 let Self {
6219 resolved_info,
6220
6221 } = &mut *out_;
6222 }
6223
6224 ::fidl_next::Wire::zero_padding(resolved_info);
6225 }
6226 }
6227
6228 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for RealmGetResolvedInfoResponse<'de>
6229 where
6230 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6231 ___D: ::fidl_next::Decoder<'de>,
6232 ___D: ::fidl_next::fuchsia::HandleDecoder,
6233 {
6234 fn decode(
6235 slot_: ::fidl_next::Slot<'_, Self>,
6236 decoder_: &mut ___D,
6237 _: (),
6238 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6239 ::fidl_next::munge! {
6240 let Self {
6241 mut resolved_info,
6242
6243 } = slot_;
6244 }
6245
6246 let _field = resolved_info.as_mut();
6247
6248 ::fidl_next::Decode::decode(resolved_info.as_mut(), decoder_, ())?;
6249
6250 Ok(())
6251 }
6252 }
6253
6254 impl<'de> ::fidl_next::IntoNatural for RealmGetResolvedInfoResponse<'de> {
6255 type Natural = crate::natural::RealmGetResolvedInfoResponse;
6256 }
6257
6258 #[derive(Debug)]
6260 #[repr(C)]
6261 pub struct StorageAdminListStorageInRealmRequest<'de> {
6262 pub relative_moniker: ::fidl_next::wire::String<'de>,
6263
6264 pub iterator:
6265 ::fidl_next::ServerEnd<crate::StorageIterator, ::fidl_next::wire::fuchsia::Channel>,
6266 }
6267
6268 static_assertions::const_assert_eq!(
6269 std::mem::size_of::<StorageAdminListStorageInRealmRequest<'_>>(),
6270 24
6271 );
6272 static_assertions::const_assert_eq!(
6273 std::mem::align_of::<StorageAdminListStorageInRealmRequest<'_>>(),
6274 8
6275 );
6276
6277 static_assertions::const_assert_eq!(
6278 std::mem::offset_of!(StorageAdminListStorageInRealmRequest<'_>, relative_moniker),
6279 0
6280 );
6281
6282 static_assertions::const_assert_eq!(
6283 std::mem::offset_of!(StorageAdminListStorageInRealmRequest<'_>, iterator),
6284 16
6285 );
6286
6287 impl ::fidl_next::Constrained for StorageAdminListStorageInRealmRequest<'_> {
6288 type Constraint = ();
6289
6290 fn validate(
6291 _: ::fidl_next::Slot<'_, Self>,
6292 _: Self::Constraint,
6293 ) -> Result<(), ::fidl_next::ValidationError> {
6294 Ok(())
6295 }
6296 }
6297
6298 unsafe impl ::fidl_next::Wire for StorageAdminListStorageInRealmRequest<'static> {
6299 type Narrowed<'de> = StorageAdminListStorageInRealmRequest<'de>;
6300
6301 #[inline]
6302 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6303 ::fidl_next::munge! {
6304 let Self {
6305 relative_moniker,
6306 iterator,
6307
6308 } = &mut *out_;
6309 }
6310
6311 ::fidl_next::Wire::zero_padding(relative_moniker);
6312
6313 ::fidl_next::Wire::zero_padding(iterator);
6314
6315 unsafe {
6316 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
6317 }
6318 }
6319 }
6320
6321 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StorageAdminListStorageInRealmRequest<'de>
6322 where
6323 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6324 ___D: ::fidl_next::Decoder<'de>,
6325 ___D: ::fidl_next::fuchsia::HandleDecoder,
6326 {
6327 fn decode(
6328 slot_: ::fidl_next::Slot<'_, Self>,
6329 decoder_: &mut ___D,
6330 _: (),
6331 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6332 if slot_.as_bytes()[20..24] != [0u8; 4] {
6333 return Err(::fidl_next::DecodeError::InvalidPadding);
6334 }
6335
6336 ::fidl_next::munge! {
6337 let Self {
6338 mut relative_moniker,
6339 mut iterator,
6340
6341 } = slot_;
6342 }
6343
6344 let _field = relative_moniker.as_mut();
6345 ::fidl_next::Constrained::validate(_field, 4096)?;
6346 ::fidl_next::Decode::decode(relative_moniker.as_mut(), decoder_, 4096)?;
6347
6348 let relative_moniker = unsafe { relative_moniker.deref_unchecked() };
6349
6350 if relative_moniker.len() > 4096 {
6351 return Err(::fidl_next::DecodeError::VectorTooLong {
6352 size: relative_moniker.len() as u64,
6353 limit: 4096,
6354 });
6355 }
6356
6357 let _field = iterator.as_mut();
6358
6359 ::fidl_next::Decode::decode(iterator.as_mut(), decoder_, ())?;
6360
6361 Ok(())
6362 }
6363 }
6364
6365 impl<'de> ::fidl_next::IntoNatural for StorageAdminListStorageInRealmRequest<'de> {
6366 type Natural = crate::natural::StorageAdminListStorageInRealmRequest;
6367 }
6368
6369 #[derive(Debug)]
6371 #[repr(C)]
6372 pub struct StorageAdminOpenStorageRequest<'de> {
6373 pub relative_moniker: ::fidl_next::wire::String<'de>,
6374
6375 pub object: ::fidl_next::ServerEnd<
6376 ::fidl_next_fuchsia_io::Node,
6377 ::fidl_next::wire::fuchsia::Channel,
6378 >,
6379 }
6380
6381 static_assertions::const_assert_eq!(
6382 std::mem::size_of::<StorageAdminOpenStorageRequest<'_>>(),
6383 24
6384 );
6385 static_assertions::const_assert_eq!(
6386 std::mem::align_of::<StorageAdminOpenStorageRequest<'_>>(),
6387 8
6388 );
6389
6390 static_assertions::const_assert_eq!(
6391 std::mem::offset_of!(StorageAdminOpenStorageRequest<'_>, relative_moniker),
6392 0
6393 );
6394
6395 static_assertions::const_assert_eq!(
6396 std::mem::offset_of!(StorageAdminOpenStorageRequest<'_>, object),
6397 16
6398 );
6399
6400 impl ::fidl_next::Constrained for StorageAdminOpenStorageRequest<'_> {
6401 type Constraint = ();
6402
6403 fn validate(
6404 _: ::fidl_next::Slot<'_, Self>,
6405 _: Self::Constraint,
6406 ) -> Result<(), ::fidl_next::ValidationError> {
6407 Ok(())
6408 }
6409 }
6410
6411 unsafe impl ::fidl_next::Wire for StorageAdminOpenStorageRequest<'static> {
6412 type Narrowed<'de> = StorageAdminOpenStorageRequest<'de>;
6413
6414 #[inline]
6415 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6416 ::fidl_next::munge! {
6417 let Self {
6418 relative_moniker,
6419 object,
6420
6421 } = &mut *out_;
6422 }
6423
6424 ::fidl_next::Wire::zero_padding(relative_moniker);
6425
6426 ::fidl_next::Wire::zero_padding(object);
6427
6428 unsafe {
6429 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
6430 }
6431 }
6432 }
6433
6434 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for StorageAdminOpenStorageRequest<'de>
6435 where
6436 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6437 ___D: ::fidl_next::Decoder<'de>,
6438 ___D: ::fidl_next::fuchsia::HandleDecoder,
6439 {
6440 fn decode(
6441 slot_: ::fidl_next::Slot<'_, Self>,
6442 decoder_: &mut ___D,
6443 _: (),
6444 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6445 if slot_.as_bytes()[20..24] != [0u8; 4] {
6446 return Err(::fidl_next::DecodeError::InvalidPadding);
6447 }
6448
6449 ::fidl_next::munge! {
6450 let Self {
6451 mut relative_moniker,
6452 mut object,
6453
6454 } = slot_;
6455 }
6456
6457 let _field = relative_moniker.as_mut();
6458 ::fidl_next::Constrained::validate(_field, 4096)?;
6459 ::fidl_next::Decode::decode(relative_moniker.as_mut(), decoder_, 4096)?;
6460
6461 let relative_moniker = unsafe { relative_moniker.deref_unchecked() };
6462
6463 if relative_moniker.len() > 4096 {
6464 return Err(::fidl_next::DecodeError::VectorTooLong {
6465 size: relative_moniker.len() as u64,
6466 limit: 4096,
6467 });
6468 }
6469
6470 let _field = object.as_mut();
6471
6472 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
6473
6474 Ok(())
6475 }
6476 }
6477
6478 impl<'de> ::fidl_next::IntoNatural for StorageAdminOpenStorageRequest<'de> {
6479 type Natural = crate::natural::StorageAdminOpenStorageRequest;
6480 }
6481
6482 #[derive(Debug)]
6484 #[repr(C)]
6485 pub struct StorageAdminOpenComponentStorageByIdRequest<'de> {
6486 pub id: ::fidl_next::wire::String<'de>,
6487
6488 pub object: ::fidl_next::ServerEnd<
6489 ::fidl_next_fuchsia_io::Node,
6490 ::fidl_next::wire::fuchsia::Channel,
6491 >,
6492 }
6493
6494 static_assertions::const_assert_eq!(
6495 std::mem::size_of::<StorageAdminOpenComponentStorageByIdRequest<'_>>(),
6496 24
6497 );
6498 static_assertions::const_assert_eq!(
6499 std::mem::align_of::<StorageAdminOpenComponentStorageByIdRequest<'_>>(),
6500 8
6501 );
6502
6503 static_assertions::const_assert_eq!(
6504 std::mem::offset_of!(StorageAdminOpenComponentStorageByIdRequest<'_>, id),
6505 0
6506 );
6507
6508 static_assertions::const_assert_eq!(
6509 std::mem::offset_of!(StorageAdminOpenComponentStorageByIdRequest<'_>, object),
6510 16
6511 );
6512
6513 impl ::fidl_next::Constrained for StorageAdminOpenComponentStorageByIdRequest<'_> {
6514 type Constraint = ();
6515
6516 fn validate(
6517 _: ::fidl_next::Slot<'_, Self>,
6518 _: Self::Constraint,
6519 ) -> Result<(), ::fidl_next::ValidationError> {
6520 Ok(())
6521 }
6522 }
6523
6524 unsafe impl ::fidl_next::Wire for StorageAdminOpenComponentStorageByIdRequest<'static> {
6525 type Narrowed<'de> = StorageAdminOpenComponentStorageByIdRequest<'de>;
6526
6527 #[inline]
6528 fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
6529 ::fidl_next::munge! {
6530 let Self {
6531 id,
6532 object,
6533
6534 } = &mut *out_;
6535 }
6536
6537 ::fidl_next::Wire::zero_padding(id);
6538
6539 ::fidl_next::Wire::zero_padding(object);
6540
6541 unsafe {
6542 out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
6543 }
6544 }
6545 }
6546
6547 unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
6548 for StorageAdminOpenComponentStorageByIdRequest<'de>
6549 where
6550 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6551 ___D: ::fidl_next::Decoder<'de>,
6552 ___D: ::fidl_next::fuchsia::HandleDecoder,
6553 {
6554 fn decode(
6555 slot_: ::fidl_next::Slot<'_, Self>,
6556 decoder_: &mut ___D,
6557 _: (),
6558 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6559 if slot_.as_bytes()[20..24] != [0u8; 4] {
6560 return Err(::fidl_next::DecodeError::InvalidPadding);
6561 }
6562
6563 ::fidl_next::munge! {
6564 let Self {
6565 mut id,
6566 mut object,
6567
6568 } = slot_;
6569 }
6570
6571 let _field = id.as_mut();
6572 ::fidl_next::Constrained::validate(_field, 64)?;
6573 ::fidl_next::Decode::decode(id.as_mut(), decoder_, 64)?;
6574
6575 let id = unsafe { id.deref_unchecked() };
6576
6577 if id.len() > 64 {
6578 return Err(::fidl_next::DecodeError::VectorTooLong {
6579 size: id.len() as u64,
6580 limit: 64,
6581 });
6582 }
6583
6584 let _field = object.as_mut();
6585
6586 ::fidl_next::Decode::decode(object.as_mut(), decoder_, ())?;
6587
6588 Ok(())
6589 }
6590 }
6591
6592 impl<'de> ::fidl_next::IntoNatural for StorageAdminOpenComponentStorageByIdRequest<'de> {
6593 type Natural = crate::natural::StorageAdminOpenComponentStorageByIdRequest;
6594 }
6595}
6596
6597pub mod wire_optional {
6598
6599 pub use fidl_next_common_fuchsia_component::wire_optional::*;
6600
6601 #[repr(transparent)]
6602 pub struct EventPayload<'de> {
6603 pub(crate) raw: ::fidl_next::wire::Union,
6604 pub(crate) _phantom: ::core::marker::PhantomData<&'de mut [::fidl_next::Chunk]>,
6605 }
6606
6607 impl ::fidl_next::Constrained for EventPayload<'_> {
6608 type Constraint = ();
6609
6610 fn validate(
6611 _: ::fidl_next::Slot<'_, Self>,
6612 _: Self::Constraint,
6613 ) -> Result<(), ::fidl_next::ValidationError> {
6614 Ok(())
6615 }
6616 }
6617
6618 unsafe impl ::fidl_next::Wire for EventPayload<'static> {
6619 type Narrowed<'de> = EventPayload<'de>;
6620
6621 #[inline]
6622 fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
6623 ::fidl_next::munge!(let Self { raw, _phantom: _ } = out);
6624 ::fidl_next::wire::Union::zero_padding(raw);
6625 }
6626 }
6627
6628 impl<'de> EventPayload<'de> {
6629 pub fn is_some(&self) -> bool {
6630 self.raw.is_some()
6631 }
6632
6633 pub fn is_none(&self) -> bool {
6634 self.raw.is_none()
6635 }
6636
6637 pub fn as_ref(&self) -> ::core::option::Option<&crate::wire::EventPayload<'de>> {
6638 if self.is_some() { Some(unsafe { &*(self as *const Self).cast() }) } else { None }
6639 }
6640
6641 pub fn into_option(self) -> ::core::option::Option<crate::wire::EventPayload<'de>> {
6642 if self.is_some() {
6643 Some(crate::wire::EventPayload {
6644 raw: self.raw,
6645 _phantom: ::core::marker::PhantomData,
6646 })
6647 } else {
6648 None
6649 }
6650 }
6651 }
6652
6653 unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for EventPayload<'de>
6654 where
6655 ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
6656 ___D: ::fidl_next::Decoder<'de>,
6657 ___D: ::fidl_next::fuchsia::HandleDecoder,
6658 {
6659 fn decode(
6660 mut slot: ::fidl_next::Slot<'_, Self>,
6661 decoder: &mut ___D,
6662 _: (),
6663 ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
6664 ::fidl_next::munge!(let Self { mut raw, _phantom: _ } = slot.as_mut());
6665 match ::fidl_next::wire::Union::encoded_ordinal(raw.as_mut()) {
6666 1 => ::fidl_next::wire::Union::decode_as::<
6667 ___D,
6668 crate::wire::CapabilityRequestedPayload<'de>,
6669 >(raw, decoder, ())?,
6670
6671 2 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::PurgedPayload<'de>>(
6672 raw,
6673 decoder,
6674 (),
6675 )?,
6676
6677 4 => ::fidl_next::wire::Union::decode_as::<
6678 ___D,
6679 crate::wire::DiscoveredPayload<'de>,
6680 >(raw, decoder, ())?,
6681
6682 5 => {
6683 ::fidl_next::wire::Union::decode_as::<___D, crate::wire::DestroyedPayload<'de>>(
6684 raw,
6685 decoder,
6686 (),
6687 )?
6688 }
6689
6690 6 => {
6691 ::fidl_next::wire::Union::decode_as::<___D, crate::wire::ResolvedPayload<'de>>(
6692 raw,
6693 decoder,
6694 (),
6695 )?
6696 }
6697
6698 7 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::StartedPayload<'de>>(
6699 raw,
6700 decoder,
6701 (),
6702 )?,
6703
6704 8 => ::fidl_next::wire::Union::decode_as::<___D, crate::wire::StoppedPayload<'de>>(
6705 raw,
6706 decoder,
6707 (),
6708 )?,
6709
6710 9 => ::fidl_next::wire::Union::decode_as::<
6711 ___D,
6712 crate::wire::DebugStartedPayload<'de>,
6713 >(raw, decoder, ())?,
6714
6715 10 => ::fidl_next::wire::Union::decode_as::<
6716 ___D,
6717 crate::wire::UnresolvedPayload<'de>,
6718 >(raw, decoder, ())?,
6719
6720 0 => ::fidl_next::wire::Union::decode_absent(raw)?,
6721 _ => ::fidl_next::wire::Union::decode_unknown(raw, decoder)?,
6722 }
6723
6724 Ok(())
6725 }
6726 }
6727
6728 impl<'de> ::core::fmt::Debug for EventPayload<'de> {
6729 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
6730 self.as_ref().fmt(f)
6731 }
6732 }
6733
6734 impl<'de> ::fidl_next::IntoNatural for EventPayload<'de> {
6735 type Natural = ::core::option::Option<crate::natural::EventPayload>;
6736 }
6737}
6738
6739pub mod generic {
6740
6741 pub use fidl_next_common_fuchsia_component::generic::*;
6742
6743 pub struct ControllerIsStartedResponse<T0> {
6745 pub is_started: T0,
6746 }
6747
6748 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ControllerIsStartedResponse, ___E>
6749 for ControllerIsStartedResponse<T0>
6750 where
6751 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6752 ___E: ::fidl_next::fuchsia::HandleEncoder,
6753 T0: ::fidl_next::Encode<bool, ___E>,
6754 {
6755 #[inline]
6756 fn encode(
6757 self,
6758 encoder_: &mut ___E,
6759 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerIsStartedResponse>,
6760 _: (),
6761 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6762 ::fidl_next::munge! {
6763 let crate::wire::ControllerIsStartedResponse {
6764 is_started,
6765
6766 } = out_;
6767 }
6768
6769 ::fidl_next::Encode::encode(self.is_started, encoder_, is_started, ())?;
6770
6771 Ok(())
6772 }
6773 }
6774
6775 pub struct ControllerGetExposedDictionaryResponse<T0> {
6777 pub dictionary: T0,
6778 }
6779
6780 unsafe impl<___E, T0>
6781 ::fidl_next::Encode<crate::wire::ControllerGetExposedDictionaryResponse, ___E>
6782 for ControllerGetExposedDictionaryResponse<T0>
6783 where
6784 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6785 ___E: ::fidl_next::fuchsia::HandleEncoder,
6786 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef, ___E>,
6787 {
6788 #[inline]
6789 fn encode(
6790 self,
6791 encoder_: &mut ___E,
6792 out_: &mut ::core::mem::MaybeUninit<
6793 crate::wire::ControllerGetExposedDictionaryResponse,
6794 >,
6795 _: (),
6796 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6797 ::fidl_next::munge! {
6798 let crate::wire::ControllerGetExposedDictionaryResponse {
6799 dictionary,
6800
6801 } = out_;
6802 }
6803
6804 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
6805
6806 Ok(())
6807 }
6808 }
6809
6810 pub struct ControllerGetOutputDictionaryResponse<T0> {
6812 pub dictionary: T0,
6813 }
6814
6815 unsafe impl<___E, T0>
6816 ::fidl_next::Encode<crate::wire::ControllerGetOutputDictionaryResponse, ___E>
6817 for ControllerGetOutputDictionaryResponse<T0>
6818 where
6819 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6820 ___E: ::fidl_next::fuchsia::HandleEncoder,
6821 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
6822 {
6823 #[inline]
6824 fn encode(
6825 self,
6826 encoder_: &mut ___E,
6827 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerGetOutputDictionaryResponse>,
6828 _: (),
6829 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6830 ::fidl_next::munge! {
6831 let crate::wire::ControllerGetOutputDictionaryResponse {
6832 dictionary,
6833
6834 } = out_;
6835 }
6836
6837 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
6838
6839 Ok(())
6840 }
6841 }
6842
6843 pub struct ControllerStartRequest<T0, T1> {
6845 pub args: T0,
6846
6847 pub execution_controller: T1,
6848 }
6849
6850 unsafe impl<___E, T0, T1>
6851 ::fidl_next::Encode<crate::wire::ControllerStartRequest<'static>, ___E>
6852 for ControllerStartRequest<T0, T1>
6853 where
6854 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6855 ___E: ::fidl_next::Encoder,
6856 ___E: ::fidl_next::fuchsia::HandleEncoder,
6857 T0: ::fidl_next::Encode<crate::wire::StartChildArgs<'static>, ___E>,
6858 T1: ::fidl_next::Encode<
6859 ::fidl_next::ServerEnd<
6860 crate::ExecutionController,
6861 ::fidl_next::wire::fuchsia::Channel,
6862 >,
6863 ___E,
6864 >,
6865 {
6866 #[inline]
6867 fn encode(
6868 self,
6869 encoder_: &mut ___E,
6870 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerStartRequest<'static>>,
6871 _: (),
6872 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6873 ::fidl_next::munge! {
6874 let crate::wire::ControllerStartRequest {
6875 args,
6876 execution_controller,
6877
6878 } = out_;
6879 }
6880
6881 ::fidl_next::Encode::encode(self.args, encoder_, args, ())?;
6882
6883 ::fidl_next::Encode::encode(
6884 self.execution_controller,
6885 encoder_,
6886 execution_controller,
6887 (),
6888 )?;
6889
6890 Ok(())
6891 }
6892 }
6893
6894 pub struct ControllerOpenExposedDirRequest<T0> {
6896 pub exposed_dir: T0,
6897 }
6898
6899 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::ControllerOpenExposedDirRequest, ___E>
6900 for ControllerOpenExposedDirRequest<T0>
6901 where
6902 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6903 ___E: ::fidl_next::fuchsia::HandleEncoder,
6904 T0: ::fidl_next::Encode<
6905 ::fidl_next::ServerEnd<
6906 ::fidl_next_fuchsia_io::Directory,
6907 ::fidl_next::wire::fuchsia::Channel,
6908 >,
6909 ___E,
6910 >,
6911 {
6912 #[inline]
6913 fn encode(
6914 self,
6915 encoder_: &mut ___E,
6916 out_: &mut ::core::mem::MaybeUninit<crate::wire::ControllerOpenExposedDirRequest>,
6917 _: (),
6918 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6919 ::fidl_next::munge! {
6920 let crate::wire::ControllerOpenExposedDirRequest {
6921 exposed_dir,
6922
6923 } = out_;
6924 }
6925
6926 ::fidl_next::Encode::encode(self.exposed_dir, encoder_, exposed_dir, ())?;
6927
6928 Ok(())
6929 }
6930 }
6931
6932 pub struct EventStreamGetNextResponse<T0> {
6934 pub events: T0,
6935 }
6936
6937 unsafe impl<___E, T0>
6938 ::fidl_next::Encode<crate::wire::EventStreamGetNextResponse<'static>, ___E>
6939 for EventStreamGetNextResponse<T0>
6940 where
6941 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6942 ___E: ::fidl_next::Encoder,
6943 ___E: ::fidl_next::fuchsia::HandleEncoder,
6944 T0: ::fidl_next::Encode<
6945 ::fidl_next::wire::Vector<'static, crate::wire::Event<'static>>,
6946 ___E,
6947 >,
6948 {
6949 #[inline]
6950 fn encode(
6951 self,
6952 encoder_: &mut ___E,
6953 out_: &mut ::core::mem::MaybeUninit<crate::wire::EventStreamGetNextResponse<'static>>,
6954 _: (),
6955 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6956 ::fidl_next::munge! {
6957 let crate::wire::EventStreamGetNextResponse {
6958 events,
6959
6960 } = out_;
6961 }
6962
6963 ::fidl_next::Encode::encode(self.events, encoder_, events, (4294967295, ()))?;
6964
6965 Ok(())
6966 }
6967 }
6968
6969 pub struct IntrospectorGetMonikerRequest<T0> {
6971 pub component_instance: T0,
6972 }
6973
6974 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::IntrospectorGetMonikerRequest, ___E>
6975 for IntrospectorGetMonikerRequest<T0>
6976 where
6977 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
6978 ___E: ::fidl_next::fuchsia::HandleEncoder,
6979 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::Event, ___E>,
6980 {
6981 #[inline]
6982 fn encode(
6983 self,
6984 encoder_: &mut ___E,
6985 out_: &mut ::core::mem::MaybeUninit<crate::wire::IntrospectorGetMonikerRequest>,
6986 _: (),
6987 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
6988 ::fidl_next::munge! {
6989 let crate::wire::IntrospectorGetMonikerRequest {
6990 component_instance,
6991
6992 } = out_;
6993 }
6994
6995 ::fidl_next::Encode::encode(self.component_instance, encoder_, component_instance, ())?;
6996
6997 Ok(())
6998 }
6999 }
7000
7001 pub struct NamespaceInputEntry<T0, T1> {
7003 pub path: T0,
7004
7005 pub dictionary: T1,
7006 }
7007
7008 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NamespaceInputEntry<'static>, ___E>
7009 for NamespaceInputEntry<T0, T1>
7010 where
7011 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7012 ___E: ::fidl_next::Encoder,
7013 ___E: ::fidl_next::fuchsia::HandleEncoder,
7014 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7015 T1: ::fidl_next::Encode<
7016 ::fidl_next::ClientEnd<
7017 ::fidl_next_fuchsia_component_sandbox::Dictionary,
7018 ::fidl_next::wire::fuchsia::Channel,
7019 >,
7020 ___E,
7021 >,
7022 {
7023 #[inline]
7024 fn encode(
7025 self,
7026 encoder_: &mut ___E,
7027 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceInputEntry<'static>>,
7028 _: (),
7029 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7030 ::fidl_next::munge! {
7031 let crate::wire::NamespaceInputEntry {
7032 path,
7033 dictionary,
7034
7035 } = out_;
7036 }
7037
7038 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
7039
7040 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
7041
7042 Ok(())
7043 }
7044 }
7045
7046 pub struct NamespaceCreateRequest<T0> {
7048 pub entries: T0,
7049 }
7050
7051 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NamespaceCreateRequest<'static>, ___E>
7052 for NamespaceCreateRequest<T0>
7053 where
7054 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7055 ___E: ::fidl_next::Encoder,
7056 ___E: ::fidl_next::fuchsia::HandleEncoder,
7057 T0: ::fidl_next::Encode<
7058 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry<'static>>,
7059 ___E,
7060 >,
7061 {
7062 #[inline]
7063 fn encode(
7064 self,
7065 encoder_: &mut ___E,
7066 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreateRequest<'static>>,
7067 _: (),
7068 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7069 ::fidl_next::munge! {
7070 let crate::wire::NamespaceCreateRequest {
7071 entries,
7072
7073 } = out_;
7074 }
7075
7076 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
7077
7078 Ok(())
7079 }
7080 }
7081
7082 pub struct NamespaceInputEntry2<T0, T1> {
7084 pub path: T0,
7085
7086 pub capability: T1,
7087 }
7088
7089 unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::NamespaceInputEntry2<'static>, ___E>
7090 for NamespaceInputEntry2<T0, T1>
7091 where
7092 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7093 ___E: ::fidl_next::Encoder,
7094 ___E: ::fidl_next::fuchsia::HandleEncoder,
7095 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7096 T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
7097 {
7098 #[inline]
7099 fn encode(
7100 self,
7101 encoder_: &mut ___E,
7102 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceInputEntry2<'static>>,
7103 _: (),
7104 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7105 ::fidl_next::munge! {
7106 let crate::wire::NamespaceInputEntry2 {
7107 path,
7108 capability,
7109
7110 } = out_;
7111 }
7112
7113 ::fidl_next::Encode::encode(self.path, encoder_, path, 4095)?;
7114
7115 ::fidl_next::Encode::encode(self.capability, encoder_, capability, ())?;
7116
7117 Ok(())
7118 }
7119 }
7120
7121 pub struct NamespaceCreate2Request<T0> {
7123 pub entries: T0,
7124 }
7125
7126 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NamespaceCreate2Request<'static>, ___E>
7127 for NamespaceCreate2Request<T0>
7128 where
7129 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7130 ___E: ::fidl_next::Encoder,
7131 ___E: ::fidl_next::fuchsia::HandleEncoder,
7132 T0: ::fidl_next::Encode<
7133 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry2<'static>>,
7134 ___E,
7135 >,
7136 {
7137 #[inline]
7138 fn encode(
7139 self,
7140 encoder_: &mut ___E,
7141 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreate2Request<'static>>,
7142 _: (),
7143 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7144 ::fidl_next::munge! {
7145 let crate::wire::NamespaceCreate2Request {
7146 entries,
7147
7148 } = out_;
7149 }
7150
7151 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
7152
7153 Ok(())
7154 }
7155 }
7156
7157 pub struct NamespaceCreateResponse<T0> {
7159 pub entries: T0,
7160 }
7161
7162 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NamespaceCreateResponse<'static>, ___E>
7163 for NamespaceCreateResponse<T0>
7164 where
7165 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7166 ___E: ::fidl_next::Encoder,
7167 ___E: ::fidl_next::fuchsia::HandleEncoder,
7168 T0: ::fidl_next::Encode<
7169 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceEntry<'static>>,
7170 ___E,
7171 >,
7172 {
7173 #[inline]
7174 fn encode(
7175 self,
7176 encoder_: &mut ___E,
7177 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreateResponse<'static>>,
7178 _: (),
7179 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7180 ::fidl_next::munge! {
7181 let crate::wire::NamespaceCreateResponse {
7182 entries,
7183
7184 } = out_;
7185 }
7186
7187 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
7188
7189 Ok(())
7190 }
7191 }
7192
7193 pub struct NamespaceCreate2Response<T0> {
7195 pub entries: T0,
7196 }
7197
7198 unsafe impl<___E, T0> ::fidl_next::Encode<crate::wire::NamespaceCreate2Response<'static>, ___E>
7199 for NamespaceCreate2Response<T0>
7200 where
7201 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7202 ___E: ::fidl_next::Encoder,
7203 ___E: ::fidl_next::fuchsia::HandleEncoder,
7204 T0: ::fidl_next::Encode<
7205 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceEntry<'static>>,
7206 ___E,
7207 >,
7208 {
7209 #[inline]
7210 fn encode(
7211 self,
7212 encoder_: &mut ___E,
7213 out_: &mut ::core::mem::MaybeUninit<crate::wire::NamespaceCreate2Response<'static>>,
7214 _: (),
7215 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7216 ::fidl_next::munge! {
7217 let crate::wire::NamespaceCreate2Response {
7218 entries,
7219
7220 } = out_;
7221 }
7222
7223 ::fidl_next::Encode::encode(self.entries, encoder_, entries, (4294967295, ()))?;
7224
7225 Ok(())
7226 }
7227 }
7228
7229 pub struct RealmListChildrenRequest<T0, T1> {
7231 pub collection: T0,
7232
7233 pub iter: T1,
7234 }
7235
7236 unsafe impl<___E, T0, T1>
7237 ::fidl_next::Encode<crate::wire::RealmListChildrenRequest<'static>, ___E>
7238 for RealmListChildrenRequest<T0, T1>
7239 where
7240 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7241 ___E: ::fidl_next::Encoder,
7242 ___E: ::fidl_next::fuchsia::HandleEncoder,
7243 T0: ::fidl_next::Encode<
7244 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
7245 ___E,
7246 >,
7247 T1: ::fidl_next::Encode<
7248 ::fidl_next::ServerEnd<crate::ChildIterator, ::fidl_next::wire::fuchsia::Channel>,
7249 ___E,
7250 >,
7251 {
7252 #[inline]
7253 fn encode(
7254 self,
7255 encoder_: &mut ___E,
7256 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmListChildrenRequest<'static>>,
7257 _: (),
7258 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7259 ::fidl_next::munge! {
7260 let crate::wire::RealmListChildrenRequest {
7261 collection,
7262 iter,
7263
7264 } = out_;
7265 }
7266
7267 ::fidl_next::Encode::encode(self.collection, encoder_, collection, ())?;
7268
7269 ::fidl_next::Encode::encode(self.iter, encoder_, iter, ())?;
7270
7271 Ok(())
7272 }
7273 }
7274
7275 pub struct RealmGetChildOutputDictionaryDeprecatedRequest<T0> {
7277 pub child: T0,
7278 }
7279
7280 unsafe impl<___E, T0>
7281 ::fidl_next::Encode<
7282 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
7283 ___E,
7284 > for RealmGetChildOutputDictionaryDeprecatedRequest<T0>
7285 where
7286 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7287 ___E: ::fidl_next::Encoder,
7288 ___E: ::fidl_next::fuchsia::HandleEncoder,
7289 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
7290 {
7291 #[inline]
7292 fn encode(
7293 self,
7294 encoder_: &mut ___E,
7295 out_: &mut ::core::mem::MaybeUninit<
7296 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
7297 >,
7298 _: (),
7299 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7300 ::fidl_next::munge! {
7301 let crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest {
7302 child,
7303
7304 } = out_;
7305 }
7306
7307 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
7308
7309 Ok(())
7310 }
7311 }
7312
7313 pub struct RealmGetChildOutputDictionaryDeprecatedResponse<T0> {
7315 pub dictionary: T0,
7316 }
7317
7318 unsafe impl<___E, T0>
7319 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse, ___E>
7320 for RealmGetChildOutputDictionaryDeprecatedResponse<T0>
7321 where
7322 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7323 ___E: ::fidl_next::fuchsia::HandleEncoder,
7324 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_sandbox::wire::DictionaryRef, ___E>,
7325 {
7326 #[inline]
7327 fn encode(
7328 self,
7329 encoder_: &mut ___E,
7330 out_: &mut ::core::mem::MaybeUninit<
7331 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
7332 >,
7333 _: (),
7334 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7335 ::fidl_next::munge! {
7336 let crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse {
7337 dictionary,
7338
7339 } = out_;
7340 }
7341
7342 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
7343
7344 Ok(())
7345 }
7346 }
7347
7348 pub struct RealmGetChildOutputDictionaryRequest<T0> {
7350 pub child: T0,
7351 }
7352
7353 unsafe impl<___E, T0>
7354 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryRequest<'static>, ___E>
7355 for RealmGetChildOutputDictionaryRequest<T0>
7356 where
7357 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7358 ___E: ::fidl_next::Encoder,
7359 ___E: ::fidl_next::fuchsia::HandleEncoder,
7360 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
7361 {
7362 #[inline]
7363 fn encode(
7364 self,
7365 encoder_: &mut ___E,
7366 out_: &mut ::core::mem::MaybeUninit<
7367 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
7368 >,
7369 _: (),
7370 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7371 ::fidl_next::munge! {
7372 let crate::wire::RealmGetChildOutputDictionaryRequest {
7373 child,
7374
7375 } = out_;
7376 }
7377
7378 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
7379
7380 Ok(())
7381 }
7382 }
7383
7384 pub struct RealmGetChildOutputDictionaryResponse<T0> {
7386 pub dictionary: T0,
7387 }
7388
7389 unsafe impl<___E, T0>
7390 ::fidl_next::Encode<crate::wire::RealmGetChildOutputDictionaryResponse, ___E>
7391 for RealmGetChildOutputDictionaryResponse<T0>
7392 where
7393 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7394 ___E: ::fidl_next::fuchsia::HandleEncoder,
7395 T0: ::fidl_next::Encode<::fidl_next::wire::fuchsia::EventPair, ___E>,
7396 {
7397 #[inline]
7398 fn encode(
7399 self,
7400 encoder_: &mut ___E,
7401 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmGetChildOutputDictionaryResponse>,
7402 _: (),
7403 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7404 ::fidl_next::munge! {
7405 let crate::wire::RealmGetChildOutputDictionaryResponse {
7406 dictionary,
7407
7408 } = out_;
7409 }
7410
7411 ::fidl_next::Encode::encode(self.dictionary, encoder_, dictionary, ())?;
7412
7413 Ok(())
7414 }
7415 }
7416
7417 pub struct RealmOpenControllerRequest<T0, T1> {
7419 pub child: T0,
7420
7421 pub controller: T1,
7422 }
7423
7424 unsafe impl<___E, T0, T1>
7425 ::fidl_next::Encode<crate::wire::RealmOpenControllerRequest<'static>, ___E>
7426 for RealmOpenControllerRequest<T0, T1>
7427 where
7428 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7429 ___E: ::fidl_next::Encoder,
7430 ___E: ::fidl_next::fuchsia::HandleEncoder,
7431 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
7432 T1: ::fidl_next::Encode<
7433 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
7434 ___E,
7435 >,
7436 {
7437 #[inline]
7438 fn encode(
7439 self,
7440 encoder_: &mut ___E,
7441 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmOpenControllerRequest<'static>>,
7442 _: (),
7443 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7444 ::fidl_next::munge! {
7445 let crate::wire::RealmOpenControllerRequest {
7446 child,
7447 controller,
7448
7449 } = out_;
7450 }
7451
7452 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
7453
7454 ::fidl_next::Encode::encode(self.controller, encoder_, controller, ())?;
7455
7456 Ok(())
7457 }
7458 }
7459
7460 pub struct RealmOpenExposedDirRequest<T0, T1> {
7462 pub child: T0,
7463
7464 pub exposed_dir: T1,
7465 }
7466
7467 unsafe impl<___E, T0, T1>
7468 ::fidl_next::Encode<crate::wire::RealmOpenExposedDirRequest<'static>, ___E>
7469 for RealmOpenExposedDirRequest<T0, T1>
7470 where
7471 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7472 ___E: ::fidl_next::Encoder,
7473 ___E: ::fidl_next::fuchsia::HandleEncoder,
7474 T0: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>, ___E>,
7475 T1: ::fidl_next::Encode<
7476 ::fidl_next::ServerEnd<
7477 ::fidl_next_fuchsia_io::Directory,
7478 ::fidl_next::wire::fuchsia::Channel,
7479 >,
7480 ___E,
7481 >,
7482 {
7483 #[inline]
7484 fn encode(
7485 self,
7486 encoder_: &mut ___E,
7487 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmOpenExposedDirRequest<'static>>,
7488 _: (),
7489 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7490 ::fidl_next::munge! {
7491 let crate::wire::RealmOpenExposedDirRequest {
7492 child,
7493 exposed_dir,
7494
7495 } = out_;
7496 }
7497
7498 ::fidl_next::Encode::encode(self.child, encoder_, child, ())?;
7499
7500 ::fidl_next::Encode::encode(self.exposed_dir, encoder_, exposed_dir, ())?;
7501
7502 Ok(())
7503 }
7504 }
7505
7506 pub struct RealmCreateChildRequest<T0, T1, T2> {
7508 pub collection: T0,
7509
7510 pub decl: T1,
7511
7512 pub args: T2,
7513 }
7514
7515 unsafe impl<___E, T0, T1, T2>
7516 ::fidl_next::Encode<crate::wire::RealmCreateChildRequest<'static>, ___E>
7517 for RealmCreateChildRequest<T0, T1, T2>
7518 where
7519 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7520 ___E: ::fidl_next::Encoder,
7521 ___E: ::fidl_next::fuchsia::HandleEncoder,
7522 T0: ::fidl_next::Encode<
7523 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
7524 ___E,
7525 >,
7526 T1: ::fidl_next::Encode<::fidl_next_fuchsia_component_decl::wire::Child<'static>, ___E>,
7527 T2: ::fidl_next::Encode<crate::wire::CreateChildArgs<'static>, ___E>,
7528 {
7529 #[inline]
7530 fn encode(
7531 self,
7532 encoder_: &mut ___E,
7533 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmCreateChildRequest<'static>>,
7534 _: (),
7535 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7536 ::fidl_next::munge! {
7537 let crate::wire::RealmCreateChildRequest {
7538 collection,
7539 decl,
7540 args,
7541
7542 } = out_;
7543 }
7544
7545 ::fidl_next::Encode::encode(self.collection, encoder_, collection, ())?;
7546
7547 ::fidl_next::Encode::encode(self.decl, encoder_, decl, ())?;
7548
7549 ::fidl_next::Encode::encode(self.args, encoder_, args, ())?;
7550
7551 Ok(())
7552 }
7553 }
7554
7555 pub struct RealmGetResolvedInfoResponse<T0> {
7557 pub resolved_info: T0,
7558 }
7559
7560 unsafe impl<___E, T0>
7561 ::fidl_next::Encode<crate::wire::RealmGetResolvedInfoResponse<'static>, ___E>
7562 for RealmGetResolvedInfoResponse<T0>
7563 where
7564 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7565 ___E: ::fidl_next::Encoder,
7566 ___E: ::fidl_next::fuchsia::HandleEncoder,
7567 T0: ::fidl_next::Encode<
7568 ::fidl_next_fuchsia_component_resolution::wire::Component<'static>,
7569 ___E,
7570 >,
7571 {
7572 #[inline]
7573 fn encode(
7574 self,
7575 encoder_: &mut ___E,
7576 out_: &mut ::core::mem::MaybeUninit<crate::wire::RealmGetResolvedInfoResponse<'static>>,
7577 _: (),
7578 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7579 ::fidl_next::munge! {
7580 let crate::wire::RealmGetResolvedInfoResponse {
7581 resolved_info,
7582
7583 } = out_;
7584 }
7585
7586 ::fidl_next::Encode::encode(self.resolved_info, encoder_, resolved_info, ())?;
7587
7588 Ok(())
7589 }
7590 }
7591
7592 pub struct StorageAdminListStorageInRealmRequest<T0, T1> {
7594 pub relative_moniker: T0,
7595
7596 pub iterator: T1,
7597 }
7598
7599 unsafe impl<___E, T0, T1>
7600 ::fidl_next::Encode<crate::wire::StorageAdminListStorageInRealmRequest<'static>, ___E>
7601 for StorageAdminListStorageInRealmRequest<T0, T1>
7602 where
7603 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7604 ___E: ::fidl_next::Encoder,
7605 ___E: ::fidl_next::fuchsia::HandleEncoder,
7606 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7607 T1: ::fidl_next::Encode<
7608 ::fidl_next::ServerEnd<crate::StorageIterator, ::fidl_next::wire::fuchsia::Channel>,
7609 ___E,
7610 >,
7611 {
7612 #[inline]
7613 fn encode(
7614 self,
7615 encoder_: &mut ___E,
7616 out_: &mut ::core::mem::MaybeUninit<
7617 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
7618 >,
7619 _: (),
7620 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7621 ::fidl_next::munge! {
7622 let crate::wire::StorageAdminListStorageInRealmRequest {
7623 relative_moniker,
7624 iterator,
7625
7626 } = out_;
7627 }
7628
7629 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
7630
7631 ::fidl_next::Encode::encode(self.iterator, encoder_, iterator, ())?;
7632
7633 Ok(())
7634 }
7635 }
7636
7637 pub struct StorageAdminOpenStorageRequest<T0, T1> {
7639 pub relative_moniker: T0,
7640
7641 pub object: T1,
7642 }
7643
7644 unsafe impl<___E, T0, T1>
7645 ::fidl_next::Encode<crate::wire::StorageAdminOpenStorageRequest<'static>, ___E>
7646 for StorageAdminOpenStorageRequest<T0, T1>
7647 where
7648 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7649 ___E: ::fidl_next::Encoder,
7650 ___E: ::fidl_next::fuchsia::HandleEncoder,
7651 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7652 T1: ::fidl_next::Encode<
7653 ::fidl_next::ServerEnd<
7654 ::fidl_next_fuchsia_io::Node,
7655 ::fidl_next::wire::fuchsia::Channel,
7656 >,
7657 ___E,
7658 >,
7659 {
7660 #[inline]
7661 fn encode(
7662 self,
7663 encoder_: &mut ___E,
7664 out_: &mut ::core::mem::MaybeUninit<
7665 crate::wire::StorageAdminOpenStorageRequest<'static>,
7666 >,
7667 _: (),
7668 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7669 ::fidl_next::munge! {
7670 let crate::wire::StorageAdminOpenStorageRequest {
7671 relative_moniker,
7672 object,
7673
7674 } = out_;
7675 }
7676
7677 ::fidl_next::Encode::encode(self.relative_moniker, encoder_, relative_moniker, 4096)?;
7678
7679 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
7680
7681 Ok(())
7682 }
7683 }
7684
7685 pub struct StorageAdminOpenComponentStorageByIdRequest<T0, T1> {
7687 pub id: T0,
7688
7689 pub object: T1,
7690 }
7691
7692 unsafe impl<___E, T0, T1>
7693 ::fidl_next::Encode<crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>, ___E>
7694 for StorageAdminOpenComponentStorageByIdRequest<T0, T1>
7695 where
7696 ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
7697 ___E: ::fidl_next::Encoder,
7698 ___E: ::fidl_next::fuchsia::HandleEncoder,
7699 T0: ::fidl_next::Encode<::fidl_next::wire::String<'static>, ___E>,
7700 T1: ::fidl_next::Encode<
7701 ::fidl_next::ServerEnd<
7702 ::fidl_next_fuchsia_io::Node,
7703 ::fidl_next::wire::fuchsia::Channel,
7704 >,
7705 ___E,
7706 >,
7707 {
7708 #[inline]
7709 fn encode(
7710 self,
7711 encoder_: &mut ___E,
7712 out_: &mut ::core::mem::MaybeUninit<
7713 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
7714 >,
7715 _: (),
7716 ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
7717 ::fidl_next::munge! {
7718 let crate::wire::StorageAdminOpenComponentStorageByIdRequest {
7719 id,
7720 object,
7721
7722 } = out_;
7723 }
7724
7725 ::fidl_next::Encode::encode(self.id, encoder_, id, 64)?;
7726
7727 ::fidl_next::Encode::encode(self.object, encoder_, object, ())?;
7728
7729 Ok(())
7730 }
7731 }
7732}
7733
7734pub use self::natural::*;
7735
7736#[doc = " A protocol used to operate on a component.\n\n One may get access to a `Controller` when creating a component with the\n `Realm.CreateChild` method. You may also obtain a `Controller` for an\n existing child component with the `Realm.OpenController` method.\n"]
7738#[derive(PartialEq, Debug)]
7739pub struct Controller;
7740
7741#[cfg(target_os = "fuchsia")]
7742impl ::fidl_next::HasTransport for Controller {
7743 type Transport = ::fidl_next::fuchsia::zx::Channel;
7744}
7745
7746pub mod controller {
7747 pub mod prelude {
7748 pub use crate::{Controller, ControllerClientHandler, ControllerServerHandler, controller};
7749
7750 pub use crate::natural::ControllerOpenExposedDirRequest;
7751
7752 pub use crate::natural::ControllerStartRequest;
7753
7754 pub use crate::natural::ControllerDestroyResponse;
7755
7756 pub use crate::natural::ControllerGetExposedDictionaryResponse;
7757
7758 pub use crate::natural::ControllerGetOutputDictionaryResponse;
7759
7760 pub use crate::natural::ControllerIsStartedResponse;
7761
7762 pub use crate::natural::ControllerOpenExposedDirResponse;
7763
7764 pub use crate::natural::ControllerStartResponse;
7765
7766 pub use crate::natural::Error;
7767 }
7768
7769 pub struct Start;
7770
7771 impl ::fidl_next::Method for Start {
7772 const ORDINAL: u64 = 7532130149195770565;
7773 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7774 ::fidl_next::protocol::Flexibility::Flexible;
7775
7776 type Protocol = crate::Controller;
7777
7778 type Request = crate::wire::ControllerStartRequest<'static>;
7779 }
7780
7781 impl ::fidl_next::TwoWayMethod for Start {
7782 type Response = ::fidl_next::wire::FlexibleResult<
7783 'static,
7784 crate::wire::ControllerStartResponse,
7785 crate::wire::Error,
7786 >;
7787 }
7788
7789 impl<___R> ::fidl_next::Respond<___R> for Start {
7790 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
7791
7792 fn respond(response: ___R) -> Self::Output {
7793 ::fidl_next::FlexibleResult::Ok(response)
7794 }
7795 }
7796
7797 impl<___R> ::fidl_next::RespondErr<___R> for Start {
7798 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7799
7800 fn respond_err(response: ___R) -> Self::Output {
7801 ::fidl_next::FlexibleResult::Err(response)
7802 }
7803 }
7804
7805 pub struct IsStarted;
7806
7807 impl ::fidl_next::Method for IsStarted {
7808 const ORDINAL: u64 = 2402079833990398915;
7809 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7810 ::fidl_next::protocol::Flexibility::Flexible;
7811
7812 type Protocol = crate::Controller;
7813
7814 type Request = ::fidl_next::wire::EmptyMessageBody;
7815 }
7816
7817 impl ::fidl_next::TwoWayMethod for IsStarted {
7818 type Response = ::fidl_next::wire::FlexibleResult<
7819 'static,
7820 crate::wire::ControllerIsStartedResponse,
7821 crate::wire::Error,
7822 >;
7823 }
7824
7825 impl<___R> ::fidl_next::Respond<___R> for IsStarted {
7826 type Output = ::fidl_next::FlexibleResult<
7827 crate::generic::ControllerIsStartedResponse<___R>,
7828 ::fidl_next::util::Never,
7829 >;
7830
7831 fn respond(response: ___R) -> Self::Output {
7832 ::fidl_next::FlexibleResult::Ok(crate::generic::ControllerIsStartedResponse {
7833 is_started: response,
7834 })
7835 }
7836 }
7837
7838 impl<___R> ::fidl_next::RespondErr<___R> for IsStarted {
7839 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7840
7841 fn respond_err(response: ___R) -> Self::Output {
7842 ::fidl_next::FlexibleResult::Err(response)
7843 }
7844 }
7845
7846 pub struct OpenExposedDir;
7847
7848 impl ::fidl_next::Method for OpenExposedDir {
7849 const ORDINAL: u64 = 2683208291886099860;
7850 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7851 ::fidl_next::protocol::Flexibility::Strict;
7852
7853 type Protocol = crate::Controller;
7854
7855 type Request = crate::wire::ControllerOpenExposedDirRequest;
7856 }
7857
7858 impl ::fidl_next::TwoWayMethod for OpenExposedDir {
7859 type Response = ::fidl_next::wire::Result<
7860 'static,
7861 crate::wire::ControllerOpenExposedDirResponse,
7862 crate::wire::Error,
7863 >;
7864 }
7865
7866 impl<___R> ::fidl_next::Respond<___R> for OpenExposedDir {
7867 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
7868
7869 fn respond(response: ___R) -> Self::Output {
7870 ::core::result::Result::Ok(response)
7871 }
7872 }
7873
7874 impl<___R> ::fidl_next::RespondErr<___R> for OpenExposedDir {
7875 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
7876
7877 fn respond_err(response: ___R) -> Self::Output {
7878 ::core::result::Result::Err(response)
7879 }
7880 }
7881
7882 pub struct GetExposedDictionary;
7883
7884 impl ::fidl_next::Method for GetExposedDictionary {
7885 const ORDINAL: u64 = 9099583788120940443;
7886 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7887 ::fidl_next::protocol::Flexibility::Flexible;
7888
7889 type Protocol = crate::Controller;
7890
7891 type Request = ::fidl_next::wire::EmptyMessageBody;
7892 }
7893
7894 impl ::fidl_next::TwoWayMethod for GetExposedDictionary {
7895 type Response = ::fidl_next::wire::FlexibleResult<
7896 'static,
7897 crate::wire::ControllerGetExposedDictionaryResponse,
7898 crate::wire::Error,
7899 >;
7900 }
7901
7902 impl<___R> ::fidl_next::Respond<___R> for GetExposedDictionary {
7903 type Output = ::fidl_next::FlexibleResult<
7904 crate::generic::ControllerGetExposedDictionaryResponse<___R>,
7905 ::fidl_next::util::Never,
7906 >;
7907
7908 fn respond(response: ___R) -> Self::Output {
7909 ::fidl_next::FlexibleResult::Ok(
7910 crate::generic::ControllerGetExposedDictionaryResponse { dictionary: response },
7911 )
7912 }
7913 }
7914
7915 impl<___R> ::fidl_next::RespondErr<___R> for GetExposedDictionary {
7916 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7917
7918 fn respond_err(response: ___R) -> Self::Output {
7919 ::fidl_next::FlexibleResult::Err(response)
7920 }
7921 }
7922
7923 pub struct GetOutputDictionary;
7924
7925 impl ::fidl_next::Method for GetOutputDictionary {
7926 const ORDINAL: u64 = 4182795765624263201;
7927 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7928 ::fidl_next::protocol::Flexibility::Flexible;
7929
7930 type Protocol = crate::Controller;
7931
7932 type Request = ::fidl_next::wire::EmptyMessageBody;
7933 }
7934
7935 impl ::fidl_next::TwoWayMethod for GetOutputDictionary {
7936 type Response = ::fidl_next::wire::FlexibleResult<
7937 'static,
7938 crate::wire::ControllerGetOutputDictionaryResponse,
7939 crate::wire::Error,
7940 >;
7941 }
7942
7943 impl<___R> ::fidl_next::Respond<___R> for GetOutputDictionary {
7944 type Output = ::fidl_next::FlexibleResult<
7945 crate::generic::ControllerGetOutputDictionaryResponse<___R>,
7946 ::fidl_next::util::Never,
7947 >;
7948
7949 fn respond(response: ___R) -> Self::Output {
7950 ::fidl_next::FlexibleResult::Ok(crate::generic::ControllerGetOutputDictionaryResponse {
7951 dictionary: response,
7952 })
7953 }
7954 }
7955
7956 impl<___R> ::fidl_next::RespondErr<___R> for GetOutputDictionary {
7957 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7958
7959 fn respond_err(response: ___R) -> Self::Output {
7960 ::fidl_next::FlexibleResult::Err(response)
7961 }
7962 }
7963
7964 pub struct Destroy;
7965
7966 impl ::fidl_next::Method for Destroy {
7967 const ORDINAL: u64 = 8381937394141370177;
7968 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
7969 ::fidl_next::protocol::Flexibility::Flexible;
7970
7971 type Protocol = crate::Controller;
7972
7973 type Request = ::fidl_next::wire::EmptyMessageBody;
7974 }
7975
7976 impl ::fidl_next::TwoWayMethod for Destroy {
7977 type Response = ::fidl_next::wire::FlexibleResult<
7978 'static,
7979 crate::wire::ControllerDestroyResponse,
7980 crate::wire::Error,
7981 >;
7982 }
7983
7984 impl<___R> ::fidl_next::Respond<___R> for Destroy {
7985 type Output = ::fidl_next::FlexibleResult<___R, ::fidl_next::util::Never>;
7986
7987 fn respond(response: ___R) -> Self::Output {
7988 ::fidl_next::FlexibleResult::Ok(response)
7989 }
7990 }
7991
7992 impl<___R> ::fidl_next::RespondErr<___R> for Destroy {
7993 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
7994
7995 fn respond_err(response: ___R) -> Self::Output {
7996 ::fidl_next::FlexibleResult::Err(response)
7997 }
7998 }
7999
8000 mod ___detail {
8001 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Controller
8002 where
8003 ___T: ::fidl_next::Transport,
8004 {
8005 type Client = ControllerClient<___T>;
8006 type Server = ControllerServer<___T>;
8007 }
8008
8009 #[repr(transparent)]
8011 pub struct ControllerClient<___T: ::fidl_next::Transport> {
8012 #[allow(dead_code)]
8013 client: ::fidl_next::protocol::Client<___T>,
8014 }
8015
8016 impl<___T> ControllerClient<___T>
8017 where
8018 ___T: ::fidl_next::Transport,
8019 {
8020 #[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"]
8021 pub fn start(
8022 &self,
8023
8024 args: impl ::fidl_next::Encode<
8025 crate::wire::StartChildArgs<'static>,
8026 <___T as ::fidl_next::Transport>::SendBuffer,
8027 >,
8028
8029 execution_controller: impl ::fidl_next::Encode<
8030 ::fidl_next::ServerEnd<
8031 crate::ExecutionController,
8032 ::fidl_next::wire::fuchsia::Channel,
8033 >,
8034 <___T as ::fidl_next::Transport>::SendBuffer,
8035 >,
8036 ) -> ::fidl_next::TwoWayFuture<'_, super::Start, ___T>
8037 where
8038 <___T as ::fidl_next::Transport>::SendBuffer:
8039 ::fidl_next::encoder::InternalHandleEncoder,
8040 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
8041 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8042 {
8043 self.start_with(crate::generic::ControllerStartRequest {
8044 args,
8045
8046 execution_controller,
8047 })
8048 }
8049
8050 #[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"]
8051 pub fn start_with<___R>(
8052 &self,
8053 request: ___R,
8054 ) -> ::fidl_next::TwoWayFuture<'_, super::Start, ___T>
8055 where
8056 ___R: ::fidl_next::Encode<
8057 crate::wire::ControllerStartRequest<'static>,
8058 <___T as ::fidl_next::Transport>::SendBuffer,
8059 >,
8060 {
8061 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8062 7532130149195770565,
8063 <super::Start as ::fidl_next::Method>::FLEXIBILITY,
8064 request,
8065 ))
8066 }
8067
8068 #[doc = " Returns true if this instance is currently running.\n"]
8069 pub fn is_started(&self) -> ::fidl_next::TwoWayFuture<'_, super::IsStarted, ___T> {
8070 ::fidl_next::TwoWayFuture::from_untyped(
8071 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8072 2402079833990398915,
8073 <super::IsStarted as ::fidl_next::Method>::FLEXIBILITY,
8074 (),
8075 ),
8076 )
8077 }
8078
8079 #[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"]
8080 pub fn open_exposed_dir(
8081 &self,
8082
8083 exposed_dir: impl ::fidl_next::Encode<
8084 ::fidl_next::ServerEnd<
8085 ::fidl_next_fuchsia_io::Directory,
8086 ::fidl_next::wire::fuchsia::Channel,
8087 >,
8088 <___T as ::fidl_next::Transport>::SendBuffer,
8089 >,
8090 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenExposedDir, ___T>
8091 where
8092 <___T as ::fidl_next::Transport>::SendBuffer:
8093 ::fidl_next::encoder::InternalHandleEncoder,
8094 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8095 {
8096 self.open_exposed_dir_with(crate::generic::ControllerOpenExposedDirRequest {
8097 exposed_dir,
8098 })
8099 }
8100
8101 #[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"]
8102 pub fn open_exposed_dir_with<___R>(
8103 &self,
8104 request: ___R,
8105 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenExposedDir, ___T>
8106 where
8107 ___R: ::fidl_next::Encode<
8108 crate::wire::ControllerOpenExposedDirRequest,
8109 <___T as ::fidl_next::Transport>::SendBuffer,
8110 >,
8111 {
8112 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8113 2683208291886099860,
8114 <super::OpenExposedDir as ::fidl_next::Method>::FLEXIBILITY,
8115 request,
8116 ))
8117 }
8118
8119 #[doc = " Returns the dictionary containing the component\'s exposed capabilities.\n"]
8120 pub fn get_exposed_dictionary(
8121 &self,
8122 ) -> ::fidl_next::TwoWayFuture<'_, super::GetExposedDictionary, ___T> {
8123 ::fidl_next::TwoWayFuture::from_untyped(
8124 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8125 9099583788120940443,
8126 <super::GetExposedDictionary as ::fidl_next::Method>::FLEXIBILITY,
8127 (),
8128 ),
8129 )
8130 }
8131
8132 #[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"]
8133 pub fn get_output_dictionary(
8134 &self,
8135 ) -> ::fidl_next::TwoWayFuture<'_, super::GetOutputDictionary, ___T> {
8136 ::fidl_next::TwoWayFuture::from_untyped(
8137 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8138 4182795765624263201,
8139 <super::GetOutputDictionary as ::fidl_next::Method>::FLEXIBILITY,
8140 (),
8141 ),
8142 )
8143 }
8144
8145 #[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"]
8146 pub fn destroy(&self) -> ::fidl_next::TwoWayFuture<'_, super::Destroy, ___T> {
8147 ::fidl_next::TwoWayFuture::from_untyped(
8148 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8149 8381937394141370177,
8150 <super::Destroy as ::fidl_next::Method>::FLEXIBILITY,
8151 (),
8152 ),
8153 )
8154 }
8155 }
8156
8157 #[repr(transparent)]
8159 pub struct ControllerServer<___T: ::fidl_next::Transport> {
8160 server: ::fidl_next::protocol::Server<___T>,
8161 }
8162
8163 impl<___T> ControllerServer<___T> where ___T: ::fidl_next::Transport {}
8164 }
8165}
8166
8167pub trait ControllerClientHandler<
8171 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8172 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8173>
8174{
8175 fn on_unknown_interaction(
8176 &mut self,
8177 ordinal: u64,
8178 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
8179 ::core::future::ready(())
8180 }
8181}
8182
8183impl<___T> ControllerClientHandler<___T> for ::fidl_next::IgnoreEvents
8184where
8185 ___T: ::fidl_next::Transport,
8186{
8187 async fn on_unknown_interaction(&mut self, _: u64) {}
8188}
8189
8190impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Controller
8191where
8192 ___H: ControllerClientHandler<___T> + ::core::marker::Send,
8193 ___T: ::fidl_next::Transport,
8194{
8195 async fn on_event(
8196 handler: &mut ___H,
8197 ordinal: u64,
8198 flexibility: ::fidl_next::protocol::Flexibility,
8199 body: ::fidl_next::Body<___T>,
8200 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
8201 match ordinal {
8202 ordinal => {
8203 handler.on_unknown_interaction(ordinal).await;
8204 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
8205 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8206 } else {
8207 Ok(())
8208 }
8209 }
8210 }
8211 }
8212}
8213
8214pub trait ControllerServerHandler<
8218 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8219 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8220>
8221{
8222 #[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"]
8223 fn start(
8224 &mut self,
8225
8226 request: ::fidl_next::Request<controller::Start, ___T>,
8227
8228 responder: ::fidl_next::Responder<controller::Start, ___T>,
8229 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8230
8231 #[doc = " Returns true if this instance is currently running.\n"]
8232 fn is_started(
8233 &mut self,
8234
8235 responder: ::fidl_next::Responder<controller::IsStarted, ___T>,
8236 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8237
8238 #[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"]
8239 fn open_exposed_dir(
8240 &mut self,
8241
8242 request: ::fidl_next::Request<controller::OpenExposedDir, ___T>,
8243
8244 responder: ::fidl_next::Responder<controller::OpenExposedDir, ___T>,
8245 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8246
8247 #[doc = " Returns the dictionary containing the component\'s exposed capabilities.\n"]
8248 fn get_exposed_dictionary(
8249 &mut self,
8250
8251 responder: ::fidl_next::Responder<controller::GetExposedDictionary, ___T>,
8252 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8253
8254 #[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"]
8255 fn get_output_dictionary(
8256 &mut self,
8257
8258 responder: ::fidl_next::Responder<controller::GetOutputDictionary, ___T>,
8259 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8260
8261 #[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"]
8262 fn destroy(
8263 &mut self,
8264
8265 responder: ::fidl_next::Responder<controller::Destroy, ___T>,
8266 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8267
8268 fn on_unknown_interaction(
8269 &mut self,
8270 ordinal: u64,
8271 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
8272 ::core::future::ready(())
8273 }
8274}
8275
8276impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Controller
8277where
8278 ___H: ControllerServerHandler<___T> + ::core::marker::Send,
8279 ___T: ::fidl_next::Transport,
8280 for<'de> crate::wire::ControllerStartRequest<'de>: ::fidl_next::Decode<
8281 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8282 Constraint = (),
8283 >,
8284 for<'de> crate::wire::ControllerOpenExposedDirRequest: ::fidl_next::Decode<
8285 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8286 Constraint = (),
8287 >,
8288{
8289 async fn on_one_way(
8290 handler: &mut ___H,
8291 ordinal: u64,
8292 flexibility: ::fidl_next::protocol::Flexibility,
8293 body: ::fidl_next::Body<___T>,
8294 ) -> ::core::result::Result<
8295 (),
8296 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8297 > {
8298 match ordinal {
8299 ordinal => {
8300 handler.on_unknown_interaction(ordinal).await;
8301 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
8302 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8303 } else {
8304 Ok(())
8305 }
8306 }
8307 }
8308 }
8309
8310 async fn on_two_way(
8311 handler: &mut ___H,
8312 ordinal: u64,
8313 flexibility: ::fidl_next::protocol::Flexibility,
8314 body: ::fidl_next::Body<___T>,
8315 responder: ::fidl_next::protocol::Responder<___T>,
8316 ) -> ::core::result::Result<
8317 (),
8318 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8319 > {
8320 match ordinal {
8321 7532130149195770565 => {
8322 let responder = ::fidl_next::Responder::from_untyped(responder);
8323
8324 match ::fidl_next::AsDecoderExt::into_decoded(body) {
8325 Ok(decoded) => {
8326 handler.start(::fidl_next::Request::from_decoded(decoded), responder).await;
8327 Ok(())
8328 }
8329 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8330 ordinal: 7532130149195770565,
8331 error,
8332 }),
8333 }
8334 }
8335
8336 2402079833990398915 => {
8337 let responder = ::fidl_next::Responder::from_untyped(responder);
8338
8339 handler.is_started(responder).await;
8340 Ok(())
8341 }
8342
8343 2683208291886099860 => {
8344 let responder = ::fidl_next::Responder::from_untyped(responder);
8345
8346 match ::fidl_next::AsDecoderExt::into_decoded(body) {
8347 Ok(decoded) => {
8348 handler
8349 .open_exposed_dir(
8350 ::fidl_next::Request::from_decoded(decoded),
8351 responder,
8352 )
8353 .await;
8354 Ok(())
8355 }
8356 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8357 ordinal: 2683208291886099860,
8358 error,
8359 }),
8360 }
8361 }
8362
8363 9099583788120940443 => {
8364 let responder = ::fidl_next::Responder::from_untyped(responder);
8365
8366 handler.get_exposed_dictionary(responder).await;
8367 Ok(())
8368 }
8369
8370 4182795765624263201 => {
8371 let responder = ::fidl_next::Responder::from_untyped(responder);
8372
8373 handler.get_output_dictionary(responder).await;
8374 Ok(())
8375 }
8376
8377 8381937394141370177 => {
8378 let responder = ::fidl_next::Responder::from_untyped(responder);
8379
8380 handler.destroy(responder).await;
8381 Ok(())
8382 }
8383
8384 ordinal => {
8385 handler.on_unknown_interaction(ordinal).await;
8386 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
8387 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8388 } else {
8389 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
8390 ordinal,
8391 flexibility,
8392 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
8393 )
8394 .expect("encoding a framework error should never fail")
8395 .await?;
8396 Ok(())
8397 }
8398 }
8399 }
8400 }
8401}
8402
8403#[doc = " Listener for events on the component hierarchy.\n Can\'t be used outside of the platform.\n"]
8405#[derive(PartialEq, Debug)]
8406pub struct EventStream;
8407
8408impl ::fidl_next::Discoverable for EventStream {
8409 const PROTOCOL_NAME: &'static str = "fuchsia.component.EventStream";
8410}
8411
8412#[cfg(target_os = "fuchsia")]
8413impl ::fidl_next::HasTransport for EventStream {
8414 type Transport = ::fidl_next::fuchsia::zx::Channel;
8415}
8416
8417pub mod event_stream {
8418 pub mod prelude {
8419 pub use crate::{
8420 EventStream, EventStreamClientHandler, EventStreamServerHandler, event_stream,
8421 };
8422
8423 pub use crate::natural::EventStreamGetNextResponse;
8424 }
8425
8426 pub struct GetNext;
8427
8428 impl ::fidl_next::Method for GetNext {
8429 const ORDINAL: u64 = 4549982840421936006;
8430 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8431 ::fidl_next::protocol::Flexibility::Strict;
8432
8433 type Protocol = crate::EventStream;
8434
8435 type Request = ::fidl_next::wire::EmptyMessageBody;
8436 }
8437
8438 impl ::fidl_next::TwoWayMethod for GetNext {
8439 type Response = crate::wire::EventStreamGetNextResponse<'static>;
8440 }
8441
8442 impl<___R> ::fidl_next::Respond<___R> for GetNext {
8443 type Output = crate::generic::EventStreamGetNextResponse<___R>;
8444
8445 fn respond(response: ___R) -> Self::Output {
8446 crate::generic::EventStreamGetNextResponse { events: response }
8447 }
8448 }
8449
8450 pub struct WaitForReady;
8451
8452 impl ::fidl_next::Method for WaitForReady {
8453 const ORDINAL: u64 = 3545212058508387970;
8454 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8455 ::fidl_next::protocol::Flexibility::Strict;
8456
8457 type Protocol = crate::EventStream;
8458
8459 type Request = ::fidl_next::wire::EmptyMessageBody;
8460 }
8461
8462 impl ::fidl_next::TwoWayMethod for WaitForReady {
8463 type Response = ::fidl_next::wire::EmptyMessageBody;
8464 }
8465
8466 impl<___R> ::fidl_next::Respond<___R> for WaitForReady {
8467 type Output = ___R;
8468
8469 fn respond(response: ___R) -> Self::Output {
8470 response
8471 }
8472 }
8473
8474 mod ___detail {
8475 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::EventStream
8476 where
8477 ___T: ::fidl_next::Transport,
8478 {
8479 type Client = EventStreamClient<___T>;
8480 type Server = EventStreamServer<___T>;
8481 }
8482
8483 #[repr(transparent)]
8485 pub struct EventStreamClient<___T: ::fidl_next::Transport> {
8486 #[allow(dead_code)]
8487 client: ::fidl_next::protocol::Client<___T>,
8488 }
8489
8490 impl<___T> EventStreamClient<___T>
8491 where
8492 ___T: ::fidl_next::Transport,
8493 {
8494 pub fn get_next(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetNext, ___T> {
8495 ::fidl_next::TwoWayFuture::from_untyped(
8496 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8497 4549982840421936006,
8498 <super::GetNext as ::fidl_next::Method>::FLEXIBILITY,
8499 (),
8500 ),
8501 )
8502 }
8503
8504 #[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"]
8505 pub fn wait_for_ready(
8506 &self,
8507 ) -> ::fidl_next::TwoWayFuture<'_, super::WaitForReady, ___T> {
8508 ::fidl_next::TwoWayFuture::from_untyped(
8509 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
8510 3545212058508387970,
8511 <super::WaitForReady as ::fidl_next::Method>::FLEXIBILITY,
8512 (),
8513 ),
8514 )
8515 }
8516 }
8517
8518 #[repr(transparent)]
8520 pub struct EventStreamServer<___T: ::fidl_next::Transport> {
8521 server: ::fidl_next::protocol::Server<___T>,
8522 }
8523
8524 impl<___T> EventStreamServer<___T> where ___T: ::fidl_next::Transport {}
8525 }
8526}
8527
8528pub trait EventStreamClientHandler<
8532 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8533 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8534>
8535{
8536}
8537
8538impl<___T> EventStreamClientHandler<___T> for ::fidl_next::IgnoreEvents where
8539 ___T: ::fidl_next::Transport
8540{
8541}
8542
8543impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for EventStream
8544where
8545 ___H: EventStreamClientHandler<___T> + ::core::marker::Send,
8546 ___T: ::fidl_next::Transport,
8547{
8548 async fn on_event(
8549 handler: &mut ___H,
8550 ordinal: u64,
8551 flexibility: ::fidl_next::protocol::Flexibility,
8552 body: ::fidl_next::Body<___T>,
8553 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
8554 match ordinal {
8555 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
8556 }
8557 }
8558}
8559
8560pub trait EventStreamServerHandler<
8564 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8565 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8566>
8567{
8568 fn get_next(
8569 &mut self,
8570
8571 responder: ::fidl_next::Responder<event_stream::GetNext, ___T>,
8572 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8573
8574 #[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"]
8575 fn wait_for_ready(
8576 &mut self,
8577
8578 responder: ::fidl_next::Responder<event_stream::WaitForReady, ___T>,
8579 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8580}
8581
8582impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for EventStream
8583where
8584 ___H: EventStreamServerHandler<___T> + ::core::marker::Send,
8585 ___T: ::fidl_next::Transport,
8586{
8587 async fn on_one_way(
8588 handler: &mut ___H,
8589 ordinal: u64,
8590 flexibility: ::fidl_next::protocol::Flexibility,
8591 body: ::fidl_next::Body<___T>,
8592 ) -> ::core::result::Result<
8593 (),
8594 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8595 > {
8596 match ordinal {
8597 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
8598 }
8599 }
8600
8601 async fn on_two_way(
8602 handler: &mut ___H,
8603 ordinal: u64,
8604 flexibility: ::fidl_next::protocol::Flexibility,
8605 body: ::fidl_next::Body<___T>,
8606 responder: ::fidl_next::protocol::Responder<___T>,
8607 ) -> ::core::result::Result<
8608 (),
8609 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8610 > {
8611 match ordinal {
8612 4549982840421936006 => {
8613 let responder = ::fidl_next::Responder::from_untyped(responder);
8614
8615 handler.get_next(responder).await;
8616 Ok(())
8617 }
8618
8619 3545212058508387970 => {
8620 let responder = ::fidl_next::Responder::from_untyped(responder);
8621
8622 handler.wait_for_ready(responder).await;
8623 Ok(())
8624 }
8625
8626 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
8627 }
8628 }
8629}
8630
8631#[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"]
8633#[derive(PartialEq, Debug)]
8634pub struct Introspector;
8635
8636impl ::fidl_next::Discoverable for Introspector {
8637 const PROTOCOL_NAME: &'static str = "fuchsia.component.Introspector";
8638}
8639
8640#[cfg(target_os = "fuchsia")]
8641impl ::fidl_next::HasTransport for Introspector {
8642 type Transport = ::fidl_next::fuchsia::zx::Channel;
8643}
8644
8645pub mod introspector {
8646 pub mod prelude {
8647 pub use crate::{
8648 Introspector, IntrospectorClientHandler, IntrospectorServerHandler, introspector,
8649 };
8650
8651 pub use crate::natural::Error;
8652
8653 pub use crate::natural::IntrospectorGetMonikerRequest;
8654
8655 pub use crate::natural::IntrospectorGetMonikerResponse;
8656 }
8657
8658 pub struct GetMoniker;
8659
8660 impl ::fidl_next::Method for GetMoniker {
8661 const ORDINAL: u64 = 214344082539672664;
8662 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8663 ::fidl_next::protocol::Flexibility::Flexible;
8664
8665 type Protocol = crate::Introspector;
8666
8667 type Request = crate::wire::IntrospectorGetMonikerRequest;
8668 }
8669
8670 impl ::fidl_next::TwoWayMethod for GetMoniker {
8671 type Response = ::fidl_next::wire::FlexibleResult<
8672 'static,
8673 crate::wire::IntrospectorGetMonikerResponse<'static>,
8674 crate::wire::Error,
8675 >;
8676 }
8677
8678 impl<___R> ::fidl_next::Respond<___R> for GetMoniker {
8679 type Output = ::fidl_next::FlexibleResult<
8680 crate::generic::IntrospectorGetMonikerResponse<___R>,
8681 ::fidl_next::util::Never,
8682 >;
8683
8684 fn respond(response: ___R) -> Self::Output {
8685 ::fidl_next::FlexibleResult::Ok(crate::generic::IntrospectorGetMonikerResponse {
8686 moniker: response,
8687 })
8688 }
8689 }
8690
8691 impl<___R> ::fidl_next::RespondErr<___R> for GetMoniker {
8692 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8693
8694 fn respond_err(response: ___R) -> Self::Output {
8695 ::fidl_next::FlexibleResult::Err(response)
8696 }
8697 }
8698
8699 mod ___detail {
8700 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Introspector
8701 where
8702 ___T: ::fidl_next::Transport,
8703 {
8704 type Client = IntrospectorClient<___T>;
8705 type Server = IntrospectorServer<___T>;
8706 }
8707
8708 #[repr(transparent)]
8710 pub struct IntrospectorClient<___T: ::fidl_next::Transport> {
8711 #[allow(dead_code)]
8712 client: ::fidl_next::protocol::Client<___T>,
8713 }
8714
8715 impl<___T> IntrospectorClient<___T>
8716 where
8717 ___T: ::fidl_next::Transport,
8718 {
8719 #[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"]
8720 pub fn get_moniker(
8721 &self,
8722
8723 component_instance: impl ::fidl_next::Encode<
8724 ::fidl_next::wire::fuchsia::Event,
8725 <___T as ::fidl_next::Transport>::SendBuffer,
8726 >,
8727 ) -> ::fidl_next::TwoWayFuture<'_, super::GetMoniker, ___T>
8728 where
8729 <___T as ::fidl_next::Transport>::SendBuffer:
8730 ::fidl_next::encoder::InternalHandleEncoder,
8731 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
8732 {
8733 self.get_moniker_with(crate::generic::IntrospectorGetMonikerRequest {
8734 component_instance,
8735 })
8736 }
8737
8738 #[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"]
8739 pub fn get_moniker_with<___R>(
8740 &self,
8741 request: ___R,
8742 ) -> ::fidl_next::TwoWayFuture<'_, super::GetMoniker, ___T>
8743 where
8744 ___R: ::fidl_next::Encode<
8745 crate::wire::IntrospectorGetMonikerRequest,
8746 <___T as ::fidl_next::Transport>::SendBuffer,
8747 >,
8748 {
8749 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
8750 214344082539672664,
8751 <super::GetMoniker as ::fidl_next::Method>::FLEXIBILITY,
8752 request,
8753 ))
8754 }
8755 }
8756
8757 #[repr(transparent)]
8759 pub struct IntrospectorServer<___T: ::fidl_next::Transport> {
8760 server: ::fidl_next::protocol::Server<___T>,
8761 }
8762
8763 impl<___T> IntrospectorServer<___T> where ___T: ::fidl_next::Transport {}
8764 }
8765}
8766
8767pub trait IntrospectorClientHandler<
8771 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8772 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8773>
8774{
8775 fn on_unknown_interaction(
8776 &mut self,
8777 ordinal: u64,
8778 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
8779 ::core::future::ready(())
8780 }
8781}
8782
8783impl<___T> IntrospectorClientHandler<___T> for ::fidl_next::IgnoreEvents
8784where
8785 ___T: ::fidl_next::Transport,
8786{
8787 async fn on_unknown_interaction(&mut self, _: u64) {}
8788}
8789
8790impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Introspector
8791where
8792 ___H: IntrospectorClientHandler<___T> + ::core::marker::Send,
8793 ___T: ::fidl_next::Transport,
8794{
8795 async fn on_event(
8796 handler: &mut ___H,
8797 ordinal: u64,
8798 flexibility: ::fidl_next::protocol::Flexibility,
8799 body: ::fidl_next::Body<___T>,
8800 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
8801 match ordinal {
8802 ordinal => {
8803 handler.on_unknown_interaction(ordinal).await;
8804 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
8805 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8806 } else {
8807 Ok(())
8808 }
8809 }
8810 }
8811 }
8812}
8813
8814pub trait IntrospectorServerHandler<
8818 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
8819 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
8820>
8821{
8822 #[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"]
8823 fn get_moniker(
8824 &mut self,
8825
8826 request: ::fidl_next::Request<introspector::GetMoniker, ___T>,
8827
8828 responder: ::fidl_next::Responder<introspector::GetMoniker, ___T>,
8829 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
8830
8831 fn on_unknown_interaction(
8832 &mut self,
8833 ordinal: u64,
8834 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
8835 ::core::future::ready(())
8836 }
8837}
8838
8839impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Introspector
8840where
8841 ___H: IntrospectorServerHandler<___T> + ::core::marker::Send,
8842 ___T: ::fidl_next::Transport,
8843 for<'de> crate::wire::IntrospectorGetMonikerRequest: ::fidl_next::Decode<
8844 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
8845 Constraint = (),
8846 >,
8847{
8848 async fn on_one_way(
8849 handler: &mut ___H,
8850 ordinal: u64,
8851 flexibility: ::fidl_next::protocol::Flexibility,
8852 body: ::fidl_next::Body<___T>,
8853 ) -> ::core::result::Result<
8854 (),
8855 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8856 > {
8857 match ordinal {
8858 ordinal => {
8859 handler.on_unknown_interaction(ordinal).await;
8860 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
8861 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8862 } else {
8863 Ok(())
8864 }
8865 }
8866 }
8867 }
8868
8869 async fn on_two_way(
8870 handler: &mut ___H,
8871 ordinal: u64,
8872 flexibility: ::fidl_next::protocol::Flexibility,
8873 body: ::fidl_next::Body<___T>,
8874 responder: ::fidl_next::protocol::Responder<___T>,
8875 ) -> ::core::result::Result<
8876 (),
8877 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
8878 > {
8879 match ordinal {
8880 214344082539672664 => {
8881 let responder = ::fidl_next::Responder::from_untyped(responder);
8882
8883 match ::fidl_next::AsDecoderExt::into_decoded(body) {
8884 Ok(decoded) => {
8885 handler
8886 .get_moniker(::fidl_next::Request::from_decoded(decoded), responder)
8887 .await;
8888 Ok(())
8889 }
8890 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
8891 ordinal: 214344082539672664,
8892 error,
8893 }),
8894 }
8895 }
8896
8897 ordinal => {
8898 handler.on_unknown_interaction(ordinal).await;
8899 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
8900 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
8901 } else {
8902 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
8903 ordinal,
8904 flexibility,
8905 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
8906 )
8907 .expect("encoding a framework error should never fail")
8908 .await?;
8909 Ok(())
8910 }
8911 }
8912 }
8913 }
8914}
8915
8916#[doc = " Protocol for performing namespace operations.\n"]
8918#[derive(PartialEq, Debug)]
8919pub struct Namespace;
8920
8921impl ::fidl_next::Discoverable for Namespace {
8922 const PROTOCOL_NAME: &'static str = "fuchsia.component.Namespace";
8923}
8924
8925#[cfg(target_os = "fuchsia")]
8926impl ::fidl_next::HasTransport for Namespace {
8927 type Transport = ::fidl_next::fuchsia::zx::Channel;
8928}
8929
8930pub mod namespace {
8931 pub mod prelude {
8932 pub use crate::{Namespace, NamespaceClientHandler, NamespaceServerHandler, namespace};
8933
8934 pub use crate::natural::NamespaceCreate2Request;
8935
8936 pub use crate::natural::NamespaceCreateRequest;
8937
8938 pub use crate::natural::NamespaceError;
8939
8940 pub use crate::natural::NamespaceCreate2Response;
8941
8942 pub use crate::natural::NamespaceCreateResponse;
8943 }
8944
8945 pub struct Create;
8946
8947 impl ::fidl_next::Method for Create {
8948 const ORDINAL: u64 = 4839678630846501113;
8949 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8950 ::fidl_next::protocol::Flexibility::Flexible;
8951
8952 type Protocol = crate::Namespace;
8953
8954 type Request = crate::wire::NamespaceCreateRequest<'static>;
8955 }
8956
8957 impl ::fidl_next::TwoWayMethod for Create {
8958 type Response = ::fidl_next::wire::FlexibleResult<
8959 'static,
8960 crate::wire::NamespaceCreateResponse<'static>,
8961 crate::wire::NamespaceError,
8962 >;
8963 }
8964
8965 impl<___R> ::fidl_next::Respond<___R> for Create {
8966 type Output = ::fidl_next::FlexibleResult<
8967 crate::generic::NamespaceCreateResponse<___R>,
8968 ::fidl_next::util::Never,
8969 >;
8970
8971 fn respond(response: ___R) -> Self::Output {
8972 ::fidl_next::FlexibleResult::Ok(crate::generic::NamespaceCreateResponse {
8973 entries: response,
8974 })
8975 }
8976 }
8977
8978 impl<___R> ::fidl_next::RespondErr<___R> for Create {
8979 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
8980
8981 fn respond_err(response: ___R) -> Self::Output {
8982 ::fidl_next::FlexibleResult::Err(response)
8983 }
8984 }
8985
8986 pub struct Create2;
8987
8988 impl ::fidl_next::Method for Create2 {
8989 const ORDINAL: u64 = 7375388463768777553;
8990 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
8991 ::fidl_next::protocol::Flexibility::Flexible;
8992
8993 type Protocol = crate::Namespace;
8994
8995 type Request = crate::wire::NamespaceCreate2Request<'static>;
8996 }
8997
8998 impl ::fidl_next::TwoWayMethod for Create2 {
8999 type Response = ::fidl_next::wire::FlexibleResult<
9000 'static,
9001 crate::wire::NamespaceCreate2Response<'static>,
9002 crate::wire::NamespaceError,
9003 >;
9004 }
9005
9006 impl<___R> ::fidl_next::Respond<___R> for Create2 {
9007 type Output = ::fidl_next::FlexibleResult<
9008 crate::generic::NamespaceCreate2Response<___R>,
9009 ::fidl_next::util::Never,
9010 >;
9011
9012 fn respond(response: ___R) -> Self::Output {
9013 ::fidl_next::FlexibleResult::Ok(crate::generic::NamespaceCreate2Response {
9014 entries: response,
9015 })
9016 }
9017 }
9018
9019 impl<___R> ::fidl_next::RespondErr<___R> for Create2 {
9020 type Output = ::fidl_next::FlexibleResult<::fidl_next::util::Never, ___R>;
9021
9022 fn respond_err(response: ___R) -> Self::Output {
9023 ::fidl_next::FlexibleResult::Err(response)
9024 }
9025 }
9026
9027 mod ___detail {
9028 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Namespace
9029 where
9030 ___T: ::fidl_next::Transport,
9031 {
9032 type Client = NamespaceClient<___T>;
9033 type Server = NamespaceServer<___T>;
9034 }
9035
9036 #[repr(transparent)]
9038 pub struct NamespaceClient<___T: ::fidl_next::Transport> {
9039 #[allow(dead_code)]
9040 client: ::fidl_next::protocol::Client<___T>,
9041 }
9042
9043 impl<___T> NamespaceClient<___T>
9044 where
9045 ___T: ::fidl_next::Transport,
9046 {
9047 pub fn create(
9048 &self,
9049
9050 entries: impl ::fidl_next::Encode<
9051 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry<'static>>,
9052 <___T as ::fidl_next::Transport>::SendBuffer,
9053 >,
9054 ) -> ::fidl_next::TwoWayFuture<'_, super::Create, ___T>
9055 where
9056 <___T as ::fidl_next::Transport>::SendBuffer:
9057 ::fidl_next::encoder::InternalHandleEncoder,
9058 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9059 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9060 {
9061 self.create_with(crate::generic::NamespaceCreateRequest { entries })
9062 }
9063
9064 pub fn create_with<___R>(
9065 &self,
9066 request: ___R,
9067 ) -> ::fidl_next::TwoWayFuture<'_, super::Create, ___T>
9068 where
9069 ___R: ::fidl_next::Encode<
9070 crate::wire::NamespaceCreateRequest<'static>,
9071 <___T as ::fidl_next::Transport>::SendBuffer,
9072 >,
9073 {
9074 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9075 4839678630846501113,
9076 <super::Create as ::fidl_next::Method>::FLEXIBILITY,
9077 request,
9078 ))
9079 }
9080
9081 pub fn create2(
9082 &self,
9083
9084 entries: impl ::fidl_next::Encode<
9085 ::fidl_next::wire::Vector<'static, crate::wire::NamespaceInputEntry2<'static>>,
9086 <___T as ::fidl_next::Transport>::SendBuffer,
9087 >,
9088 ) -> ::fidl_next::TwoWayFuture<'_, super::Create2, ___T>
9089 where
9090 <___T as ::fidl_next::Transport>::SendBuffer:
9091 ::fidl_next::encoder::InternalHandleEncoder,
9092 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9093 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9094 {
9095 self.create2_with(crate::generic::NamespaceCreate2Request { entries })
9096 }
9097
9098 pub fn create2_with<___R>(
9099 &self,
9100 request: ___R,
9101 ) -> ::fidl_next::TwoWayFuture<'_, super::Create2, ___T>
9102 where
9103 ___R: ::fidl_next::Encode<
9104 crate::wire::NamespaceCreate2Request<'static>,
9105 <___T as ::fidl_next::Transport>::SendBuffer,
9106 >,
9107 {
9108 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9109 7375388463768777553,
9110 <super::Create2 as ::fidl_next::Method>::FLEXIBILITY,
9111 request,
9112 ))
9113 }
9114 }
9115
9116 #[repr(transparent)]
9118 pub struct NamespaceServer<___T: ::fidl_next::Transport> {
9119 server: ::fidl_next::protocol::Server<___T>,
9120 }
9121
9122 impl<___T> NamespaceServer<___T> where ___T: ::fidl_next::Transport {}
9123 }
9124}
9125
9126pub trait NamespaceClientHandler<
9130 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9131 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9132>
9133{
9134 fn on_unknown_interaction(
9135 &mut self,
9136 ordinal: u64,
9137 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9138 ::core::future::ready(())
9139 }
9140}
9141
9142impl<___T> NamespaceClientHandler<___T> for ::fidl_next::IgnoreEvents
9143where
9144 ___T: ::fidl_next::Transport,
9145{
9146 async fn on_unknown_interaction(&mut self, _: u64) {}
9147}
9148
9149impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Namespace
9150where
9151 ___H: NamespaceClientHandler<___T> + ::core::marker::Send,
9152 ___T: ::fidl_next::Transport,
9153{
9154 async fn on_event(
9155 handler: &mut ___H,
9156 ordinal: u64,
9157 flexibility: ::fidl_next::protocol::Flexibility,
9158 body: ::fidl_next::Body<___T>,
9159 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
9160 match ordinal {
9161 ordinal => {
9162 handler.on_unknown_interaction(ordinal).await;
9163 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9164 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9165 } else {
9166 Ok(())
9167 }
9168 }
9169 }
9170 }
9171}
9172
9173pub trait NamespaceServerHandler<
9177 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
9178 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
9179>
9180{
9181 fn create(
9182 &mut self,
9183
9184 request: ::fidl_next::Request<namespace::Create, ___T>,
9185
9186 responder: ::fidl_next::Responder<namespace::Create, ___T>,
9187 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9188
9189 fn create2(
9190 &mut self,
9191
9192 request: ::fidl_next::Request<namespace::Create2, ___T>,
9193
9194 responder: ::fidl_next::Responder<namespace::Create2, ___T>,
9195 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
9196
9197 fn on_unknown_interaction(
9198 &mut self,
9199 ordinal: u64,
9200 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
9201 ::core::future::ready(())
9202 }
9203}
9204
9205impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Namespace
9206where
9207 ___H: NamespaceServerHandler<___T> + ::core::marker::Send,
9208 ___T: ::fidl_next::Transport,
9209 for<'de> crate::wire::NamespaceCreateRequest<'de>: ::fidl_next::Decode<
9210 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9211 Constraint = (),
9212 >,
9213 for<'de> crate::wire::NamespaceCreate2Request<'de>: ::fidl_next::Decode<
9214 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
9215 Constraint = (),
9216 >,
9217{
9218 async fn on_one_way(
9219 handler: &mut ___H,
9220 ordinal: u64,
9221 flexibility: ::fidl_next::protocol::Flexibility,
9222 body: ::fidl_next::Body<___T>,
9223 ) -> ::core::result::Result<
9224 (),
9225 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9226 > {
9227 match ordinal {
9228 ordinal => {
9229 handler.on_unknown_interaction(ordinal).await;
9230 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9231 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9232 } else {
9233 Ok(())
9234 }
9235 }
9236 }
9237 }
9238
9239 async fn on_two_way(
9240 handler: &mut ___H,
9241 ordinal: u64,
9242 flexibility: ::fidl_next::protocol::Flexibility,
9243 body: ::fidl_next::Body<___T>,
9244 responder: ::fidl_next::protocol::Responder<___T>,
9245 ) -> ::core::result::Result<
9246 (),
9247 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
9248 > {
9249 match ordinal {
9250 4839678630846501113 => {
9251 let responder = ::fidl_next::Responder::from_untyped(responder);
9252
9253 match ::fidl_next::AsDecoderExt::into_decoded(body) {
9254 Ok(decoded) => {
9255 handler
9256 .create(::fidl_next::Request::from_decoded(decoded), responder)
9257 .await;
9258 Ok(())
9259 }
9260 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9261 ordinal: 4839678630846501113,
9262 error,
9263 }),
9264 }
9265 }
9266
9267 7375388463768777553 => {
9268 let responder = ::fidl_next::Responder::from_untyped(responder);
9269
9270 match ::fidl_next::AsDecoderExt::into_decoded(body) {
9271 Ok(decoded) => {
9272 handler
9273 .create2(::fidl_next::Request::from_decoded(decoded), responder)
9274 .await;
9275 Ok(())
9276 }
9277 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
9278 ordinal: 7375388463768777553,
9279 error,
9280 }),
9281 }
9282 }
9283
9284 ordinal => {
9285 handler.on_unknown_interaction(ordinal).await;
9286 if ::core::matches!(flexibility, ::fidl_next::protocol::Flexibility::Strict) {
9287 Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
9288 } else {
9289 responder.respond::<::fidl_next::wire::Flexible<'_, ::fidl_next::wire::EmptyMessageBody>>(
9290 ordinal,
9291 flexibility,
9292 ::fidl_next::Flexible::<::fidl_next::util::Never>::FrameworkErr(::fidl_next::FrameworkError::UnknownMethod),
9293 )
9294 .expect("encoding a framework error should never fail")
9295 .await?;
9296 Ok(())
9297 }
9298 }
9299 }
9300 }
9301}
9302
9303#[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"]
9305#[derive(PartialEq, Debug)]
9306pub struct Realm;
9307
9308impl ::fidl_next::Discoverable for Realm {
9309 const PROTOCOL_NAME: &'static str = "fuchsia.component.Realm";
9310}
9311
9312#[cfg(target_os = "fuchsia")]
9313impl ::fidl_next::HasTransport for Realm {
9314 type Transport = ::fidl_next::fuchsia::zx::Channel;
9315}
9316
9317pub mod realm {
9318 pub mod prelude {
9319 pub use crate::{Realm, RealmClientHandler, RealmServerHandler, realm};
9320
9321 pub use crate::natural::Error;
9322
9323 pub use crate::natural::RealmCreateChildRequest;
9324
9325 pub use crate::natural::RealmDestroyChildRequest;
9326
9327 pub use crate::natural::RealmGetChildOutputDictionaryDeprecatedRequest;
9328
9329 pub use crate::natural::RealmGetChildOutputDictionaryRequest;
9330
9331 pub use crate::natural::RealmListChildrenRequest;
9332
9333 pub use crate::natural::RealmOpenControllerRequest;
9334
9335 pub use crate::natural::RealmOpenExposedDirRequest;
9336
9337 pub use crate::natural::RealmCreateChildResponse;
9338
9339 pub use crate::natural::RealmDestroyChildResponse;
9340
9341 pub use crate::natural::RealmGetChildOutputDictionaryDeprecatedResponse;
9342
9343 pub use crate::natural::RealmGetChildOutputDictionaryResponse;
9344
9345 pub use crate::natural::RealmGetResolvedInfoResponse;
9346
9347 pub use crate::natural::RealmListChildrenResponse;
9348
9349 pub use crate::natural::RealmOpenControllerResponse;
9350
9351 pub use crate::natural::RealmOpenExposedDirResponse;
9352 }
9353
9354 pub struct OpenController;
9355
9356 impl ::fidl_next::Method for OpenController {
9357 const ORDINAL: u64 = 8165227925828473216;
9358 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9359 ::fidl_next::protocol::Flexibility::Strict;
9360
9361 type Protocol = crate::Realm;
9362
9363 type Request = crate::wire::RealmOpenControllerRequest<'static>;
9364 }
9365
9366 impl ::fidl_next::TwoWayMethod for OpenController {
9367 type Response = ::fidl_next::wire::Result<
9368 'static,
9369 crate::wire::RealmOpenControllerResponse,
9370 crate::wire::Error,
9371 >;
9372 }
9373
9374 impl<___R> ::fidl_next::Respond<___R> for OpenController {
9375 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9376
9377 fn respond(response: ___R) -> Self::Output {
9378 ::core::result::Result::Ok(response)
9379 }
9380 }
9381
9382 impl<___R> ::fidl_next::RespondErr<___R> for OpenController {
9383 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9384
9385 fn respond_err(response: ___R) -> Self::Output {
9386 ::core::result::Result::Err(response)
9387 }
9388 }
9389
9390 pub struct OpenExposedDir;
9391
9392 impl ::fidl_next::Method for OpenExposedDir {
9393 const ORDINAL: u64 = 9194435320863127852;
9394 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9395 ::fidl_next::protocol::Flexibility::Strict;
9396
9397 type Protocol = crate::Realm;
9398
9399 type Request = crate::wire::RealmOpenExposedDirRequest<'static>;
9400 }
9401
9402 impl ::fidl_next::TwoWayMethod for OpenExposedDir {
9403 type Response = ::fidl_next::wire::Result<
9404 'static,
9405 crate::wire::RealmOpenExposedDirResponse,
9406 crate::wire::Error,
9407 >;
9408 }
9409
9410 impl<___R> ::fidl_next::Respond<___R> for OpenExposedDir {
9411 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9412
9413 fn respond(response: ___R) -> Self::Output {
9414 ::core::result::Result::Ok(response)
9415 }
9416 }
9417
9418 impl<___R> ::fidl_next::RespondErr<___R> for OpenExposedDir {
9419 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9420
9421 fn respond_err(response: ___R) -> Self::Output {
9422 ::core::result::Result::Err(response)
9423 }
9424 }
9425
9426 pub struct CreateChild;
9427
9428 impl ::fidl_next::Method for CreateChild {
9429 const ORDINAL: u64 = 4892190024503489888;
9430 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9431 ::fidl_next::protocol::Flexibility::Strict;
9432
9433 type Protocol = crate::Realm;
9434
9435 type Request = crate::wire::RealmCreateChildRequest<'static>;
9436 }
9437
9438 impl ::fidl_next::TwoWayMethod for CreateChild {
9439 type Response = ::fidl_next::wire::Result<
9440 'static,
9441 crate::wire::RealmCreateChildResponse,
9442 crate::wire::Error,
9443 >;
9444 }
9445
9446 impl<___R> ::fidl_next::Respond<___R> for CreateChild {
9447 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9448
9449 fn respond(response: ___R) -> Self::Output {
9450 ::core::result::Result::Ok(response)
9451 }
9452 }
9453
9454 impl<___R> ::fidl_next::RespondErr<___R> for CreateChild {
9455 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9456
9457 fn respond_err(response: ___R) -> Self::Output {
9458 ::core::result::Result::Err(response)
9459 }
9460 }
9461
9462 pub struct DestroyChild;
9463
9464 impl ::fidl_next::Method for DestroyChild {
9465 const ORDINAL: u64 = 8203529889988252194;
9466 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9467 ::fidl_next::protocol::Flexibility::Strict;
9468
9469 type Protocol = crate::Realm;
9470
9471 type Request = crate::wire::RealmDestroyChildRequest<'static>;
9472 }
9473
9474 impl ::fidl_next::TwoWayMethod for DestroyChild {
9475 type Response = ::fidl_next::wire::Result<
9476 'static,
9477 crate::wire::RealmDestroyChildResponse,
9478 crate::wire::Error,
9479 >;
9480 }
9481
9482 impl<___R> ::fidl_next::Respond<___R> for DestroyChild {
9483 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9484
9485 fn respond(response: ___R) -> Self::Output {
9486 ::core::result::Result::Ok(response)
9487 }
9488 }
9489
9490 impl<___R> ::fidl_next::RespondErr<___R> for DestroyChild {
9491 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9492
9493 fn respond_err(response: ___R) -> Self::Output {
9494 ::core::result::Result::Err(response)
9495 }
9496 }
9497
9498 pub struct ListChildren;
9499
9500 impl ::fidl_next::Method for ListChildren {
9501 const ORDINAL: u64 = 7532454435519185057;
9502 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9503 ::fidl_next::protocol::Flexibility::Strict;
9504
9505 type Protocol = crate::Realm;
9506
9507 type Request = crate::wire::RealmListChildrenRequest<'static>;
9508 }
9509
9510 impl ::fidl_next::TwoWayMethod for ListChildren {
9511 type Response = ::fidl_next::wire::Result<
9512 'static,
9513 crate::wire::RealmListChildrenResponse,
9514 crate::wire::Error,
9515 >;
9516 }
9517
9518 impl<___R> ::fidl_next::Respond<___R> for ListChildren {
9519 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
9520
9521 fn respond(response: ___R) -> Self::Output {
9522 ::core::result::Result::Ok(response)
9523 }
9524 }
9525
9526 impl<___R> ::fidl_next::RespondErr<___R> for ListChildren {
9527 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9528
9529 fn respond_err(response: ___R) -> Self::Output {
9530 ::core::result::Result::Err(response)
9531 }
9532 }
9533
9534 pub struct GetResolvedInfo;
9535
9536 impl ::fidl_next::Method for GetResolvedInfo {
9537 const ORDINAL: u64 = 8308987710372188322;
9538 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9539 ::fidl_next::protocol::Flexibility::Strict;
9540
9541 type Protocol = crate::Realm;
9542
9543 type Request = ::fidl_next::wire::EmptyMessageBody;
9544 }
9545
9546 impl ::fidl_next::TwoWayMethod for GetResolvedInfo {
9547 type Response = ::fidl_next::wire::Result<
9548 'static,
9549 crate::wire::RealmGetResolvedInfoResponse<'static>,
9550 crate::wire::Error,
9551 >;
9552 }
9553
9554 impl<___R> ::fidl_next::Respond<___R> for GetResolvedInfo {
9555 type Output = ::core::result::Result<
9556 crate::generic::RealmGetResolvedInfoResponse<___R>,
9557 ::fidl_next::util::Never,
9558 >;
9559
9560 fn respond(response: ___R) -> Self::Output {
9561 ::core::result::Result::Ok(crate::generic::RealmGetResolvedInfoResponse {
9562 resolved_info: response,
9563 })
9564 }
9565 }
9566
9567 impl<___R> ::fidl_next::RespondErr<___R> for GetResolvedInfo {
9568 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9569
9570 fn respond_err(response: ___R) -> Self::Output {
9571 ::core::result::Result::Err(response)
9572 }
9573 }
9574
9575 pub struct GetChildOutputDictionaryDeprecated;
9576
9577 impl ::fidl_next::Method for GetChildOutputDictionaryDeprecated {
9578 const ORDINAL: u64 = 4117516026351534948;
9579 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9580 ::fidl_next::protocol::Flexibility::Strict;
9581
9582 type Protocol = crate::Realm;
9583
9584 type Request = crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>;
9585 }
9586
9587 impl ::fidl_next::TwoWayMethod for GetChildOutputDictionaryDeprecated {
9588 type Response = ::fidl_next::wire::Result<
9589 'static,
9590 crate::wire::RealmGetChildOutputDictionaryDeprecatedResponse,
9591 crate::wire::Error,
9592 >;
9593 }
9594
9595 impl<___R> ::fidl_next::Respond<___R> for GetChildOutputDictionaryDeprecated {
9596 type Output = ::core::result::Result<
9597 crate::generic::RealmGetChildOutputDictionaryDeprecatedResponse<___R>,
9598 ::fidl_next::util::Never,
9599 >;
9600
9601 fn respond(response: ___R) -> Self::Output {
9602 ::core::result::Result::Ok(
9603 crate::generic::RealmGetChildOutputDictionaryDeprecatedResponse {
9604 dictionary: response,
9605 },
9606 )
9607 }
9608 }
9609
9610 impl<___R> ::fidl_next::RespondErr<___R> for GetChildOutputDictionaryDeprecated {
9611 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9612
9613 fn respond_err(response: ___R) -> Self::Output {
9614 ::core::result::Result::Err(response)
9615 }
9616 }
9617
9618 pub struct GetChildOutputDictionary;
9619
9620 impl ::fidl_next::Method for GetChildOutputDictionary {
9621 const ORDINAL: u64 = 4781081784078915088;
9622 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
9623 ::fidl_next::protocol::Flexibility::Strict;
9624
9625 type Protocol = crate::Realm;
9626
9627 type Request = crate::wire::RealmGetChildOutputDictionaryRequest<'static>;
9628 }
9629
9630 impl ::fidl_next::TwoWayMethod for GetChildOutputDictionary {
9631 type Response = ::fidl_next::wire::Result<
9632 'static,
9633 crate::wire::RealmGetChildOutputDictionaryResponse,
9634 crate::wire::Error,
9635 >;
9636 }
9637
9638 impl<___R> ::fidl_next::Respond<___R> for GetChildOutputDictionary {
9639 type Output = ::core::result::Result<
9640 crate::generic::RealmGetChildOutputDictionaryResponse<___R>,
9641 ::fidl_next::util::Never,
9642 >;
9643
9644 fn respond(response: ___R) -> Self::Output {
9645 ::core::result::Result::Ok(crate::generic::RealmGetChildOutputDictionaryResponse {
9646 dictionary: response,
9647 })
9648 }
9649 }
9650
9651 impl<___R> ::fidl_next::RespondErr<___R> for GetChildOutputDictionary {
9652 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
9653
9654 fn respond_err(response: ___R) -> Self::Output {
9655 ::core::result::Result::Err(response)
9656 }
9657 }
9658
9659 mod ___detail {
9660 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Realm
9661 where
9662 ___T: ::fidl_next::Transport,
9663 {
9664 type Client = RealmClient<___T>;
9665 type Server = RealmServer<___T>;
9666 }
9667
9668 #[repr(transparent)]
9670 pub struct RealmClient<___T: ::fidl_next::Transport> {
9671 #[allow(dead_code)]
9672 client: ::fidl_next::protocol::Client<___T>,
9673 }
9674
9675 impl<___T> RealmClient<___T>
9676 where
9677 ___T: ::fidl_next::Transport,
9678 {
9679 #[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"]
9680 pub fn open_controller(
9681 &self,
9682
9683 child: impl ::fidl_next::Encode<
9684 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
9685 <___T as ::fidl_next::Transport>::SendBuffer,
9686 >,
9687
9688 controller: impl ::fidl_next::Encode<
9689 ::fidl_next::ServerEnd<crate::Controller, ::fidl_next::wire::fuchsia::Channel>,
9690 <___T as ::fidl_next::Transport>::SendBuffer,
9691 >,
9692 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenController, ___T>
9693 where
9694 <___T as ::fidl_next::Transport>::SendBuffer:
9695 ::fidl_next::encoder::InternalHandleEncoder,
9696 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9697 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9698 {
9699 self.open_controller_with(crate::generic::RealmOpenControllerRequest {
9700 child,
9701
9702 controller,
9703 })
9704 }
9705
9706 #[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"]
9707 pub fn open_controller_with<___R>(
9708 &self,
9709 request: ___R,
9710 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenController, ___T>
9711 where
9712 ___R: ::fidl_next::Encode<
9713 crate::wire::RealmOpenControllerRequest<'static>,
9714 <___T as ::fidl_next::Transport>::SendBuffer,
9715 >,
9716 {
9717 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9718 8165227925828473216,
9719 <super::OpenController as ::fidl_next::Method>::FLEXIBILITY,
9720 request,
9721 ))
9722 }
9723
9724 #[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"]
9725 pub fn open_exposed_dir(
9726 &self,
9727
9728 child: impl ::fidl_next::Encode<
9729 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
9730 <___T as ::fidl_next::Transport>::SendBuffer,
9731 >,
9732
9733 exposed_dir: impl ::fidl_next::Encode<
9734 ::fidl_next::ServerEnd<
9735 ::fidl_next_fuchsia_io::Directory,
9736 ::fidl_next::wire::fuchsia::Channel,
9737 >,
9738 <___T as ::fidl_next::Transport>::SendBuffer,
9739 >,
9740 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenExposedDir, ___T>
9741 where
9742 <___T as ::fidl_next::Transport>::SendBuffer:
9743 ::fidl_next::encoder::InternalHandleEncoder,
9744 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9745 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9746 {
9747 self.open_exposed_dir_with(crate::generic::RealmOpenExposedDirRequest {
9748 child,
9749
9750 exposed_dir,
9751 })
9752 }
9753
9754 #[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"]
9755 pub fn open_exposed_dir_with<___R>(
9756 &self,
9757 request: ___R,
9758 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenExposedDir, ___T>
9759 where
9760 ___R: ::fidl_next::Encode<
9761 crate::wire::RealmOpenExposedDirRequest<'static>,
9762 <___T as ::fidl_next::Transport>::SendBuffer,
9763 >,
9764 {
9765 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9766 9194435320863127852,
9767 <super::OpenExposedDir as ::fidl_next::Method>::FLEXIBILITY,
9768 request,
9769 ))
9770 }
9771
9772 #[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"]
9773 pub fn create_child(
9774 &self,
9775
9776 collection: impl ::fidl_next::Encode<
9777 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
9778 <___T as ::fidl_next::Transport>::SendBuffer,
9779 >,
9780
9781 decl: impl ::fidl_next::Encode<
9782 ::fidl_next_fuchsia_component_decl::wire::Child<'static>,
9783 <___T as ::fidl_next::Transport>::SendBuffer,
9784 >,
9785
9786 args: impl ::fidl_next::Encode<
9787 crate::wire::CreateChildArgs<'static>,
9788 <___T as ::fidl_next::Transport>::SendBuffer,
9789 >,
9790 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateChild, ___T>
9791 where
9792 <___T as ::fidl_next::Transport>::SendBuffer:
9793 ::fidl_next::encoder::InternalHandleEncoder,
9794 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9795 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9796 {
9797 self.create_child_with(crate::generic::RealmCreateChildRequest {
9798 collection,
9799
9800 decl,
9801
9802 args,
9803 })
9804 }
9805
9806 #[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"]
9807 pub fn create_child_with<___R>(
9808 &self,
9809 request: ___R,
9810 ) -> ::fidl_next::TwoWayFuture<'_, super::CreateChild, ___T>
9811 where
9812 ___R: ::fidl_next::Encode<
9813 crate::wire::RealmCreateChildRequest<'static>,
9814 <___T as ::fidl_next::Transport>::SendBuffer,
9815 >,
9816 {
9817 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9818 4892190024503489888,
9819 <super::CreateChild as ::fidl_next::Method>::FLEXIBILITY,
9820 request,
9821 ))
9822 }
9823
9824 #[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"]
9825 pub fn destroy_child(
9826 &self,
9827
9828 child: impl ::fidl_next::Encode<
9829 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
9830 <___T as ::fidl_next::Transport>::SendBuffer,
9831 >,
9832 ) -> ::fidl_next::TwoWayFuture<'_, super::DestroyChild, ___T>
9833 where
9834 <___T as ::fidl_next::Transport>::SendBuffer:
9835 ::fidl_next::encoder::InternalHandleEncoder,
9836 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9837 {
9838 self.destroy_child_with(crate::generic::RealmDestroyChildRequest { child })
9839 }
9840
9841 #[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"]
9842 pub fn destroy_child_with<___R>(
9843 &self,
9844 request: ___R,
9845 ) -> ::fidl_next::TwoWayFuture<'_, super::DestroyChild, ___T>
9846 where
9847 ___R: ::fidl_next::Encode<
9848 crate::wire::RealmDestroyChildRequest<'static>,
9849 <___T as ::fidl_next::Transport>::SendBuffer,
9850 >,
9851 {
9852 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9853 8203529889988252194,
9854 <super::DestroyChild as ::fidl_next::Method>::FLEXIBILITY,
9855 request,
9856 ))
9857 }
9858
9859 #[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"]
9860 pub fn list_children(
9861 &self,
9862
9863 collection: impl ::fidl_next::Encode<
9864 ::fidl_next_fuchsia_component_decl::wire::CollectionRef<'static>,
9865 <___T as ::fidl_next::Transport>::SendBuffer,
9866 >,
9867
9868 iter: impl ::fidl_next::Encode<
9869 ::fidl_next::ServerEnd<
9870 crate::ChildIterator,
9871 ::fidl_next::wire::fuchsia::Channel,
9872 >,
9873 <___T as ::fidl_next::Transport>::SendBuffer,
9874 >,
9875 ) -> ::fidl_next::TwoWayFuture<'_, super::ListChildren, ___T>
9876 where
9877 <___T as ::fidl_next::Transport>::SendBuffer:
9878 ::fidl_next::encoder::InternalHandleEncoder,
9879 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9880 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9881 {
9882 self.list_children_with(crate::generic::RealmListChildrenRequest {
9883 collection,
9884
9885 iter,
9886 })
9887 }
9888
9889 #[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"]
9890 pub fn list_children_with<___R>(
9891 &self,
9892 request: ___R,
9893 ) -> ::fidl_next::TwoWayFuture<'_, super::ListChildren, ___T>
9894 where
9895 ___R: ::fidl_next::Encode<
9896 crate::wire::RealmListChildrenRequest<'static>,
9897 <___T as ::fidl_next::Transport>::SendBuffer,
9898 >,
9899 {
9900 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9901 7532454435519185057,
9902 <super::ListChildren as ::fidl_next::Method>::FLEXIBILITY,
9903 request,
9904 ))
9905 }
9906
9907 #[doc = " Returns the set of information that was given to the component framework\n by this component\'s resolver.\n"]
9908 pub fn get_resolved_info(
9909 &self,
9910 ) -> ::fidl_next::TwoWayFuture<'_, super::GetResolvedInfo, ___T> {
9911 ::fidl_next::TwoWayFuture::from_untyped(
9912 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
9913 8308987710372188322,
9914 <super::GetResolvedInfo as ::fidl_next::Method>::FLEXIBILITY,
9915 (),
9916 ),
9917 )
9918 }
9919
9920 pub fn get_child_output_dictionary_deprecated(
9921 &self,
9922
9923 child: impl ::fidl_next::Encode<
9924 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
9925 <___T as ::fidl_next::Transport>::SendBuffer,
9926 >,
9927 ) -> ::fidl_next::TwoWayFuture<'_, super::GetChildOutputDictionaryDeprecated, ___T>
9928 where
9929 <___T as ::fidl_next::Transport>::SendBuffer:
9930 ::fidl_next::encoder::InternalHandleEncoder,
9931 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9932 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9933 {
9934 self.get_child_output_dictionary_deprecated_with(
9935 crate::generic::RealmGetChildOutputDictionaryDeprecatedRequest { child },
9936 )
9937 }
9938
9939 pub fn get_child_output_dictionary_deprecated_with<___R>(
9940 &self,
9941 request: ___R,
9942 ) -> ::fidl_next::TwoWayFuture<'_, super::GetChildOutputDictionaryDeprecated, ___T>
9943 where
9944 ___R: ::fidl_next::Encode<
9945 crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'static>,
9946 <___T as ::fidl_next::Transport>::SendBuffer,
9947 >,
9948 {
9949 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9950 4117516026351534948,
9951 <super::GetChildOutputDictionaryDeprecated as ::fidl_next::Method>::FLEXIBILITY,
9952 request,
9953 ))
9954 }
9955
9956 #[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"]
9957 pub fn get_child_output_dictionary(
9958 &self,
9959
9960 child: impl ::fidl_next::Encode<
9961 ::fidl_next_fuchsia_component_decl::wire::ChildRef<'static>,
9962 <___T as ::fidl_next::Transport>::SendBuffer,
9963 >,
9964 ) -> ::fidl_next::TwoWayFuture<'_, super::GetChildOutputDictionary, ___T>
9965 where
9966 <___T as ::fidl_next::Transport>::SendBuffer:
9967 ::fidl_next::encoder::InternalHandleEncoder,
9968 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
9969 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
9970 {
9971 self.get_child_output_dictionary_with(
9972 crate::generic::RealmGetChildOutputDictionaryRequest { child },
9973 )
9974 }
9975
9976 #[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"]
9977 pub fn get_child_output_dictionary_with<___R>(
9978 &self,
9979 request: ___R,
9980 ) -> ::fidl_next::TwoWayFuture<'_, super::GetChildOutputDictionary, ___T>
9981 where
9982 ___R: ::fidl_next::Encode<
9983 crate::wire::RealmGetChildOutputDictionaryRequest<'static>,
9984 <___T as ::fidl_next::Transport>::SendBuffer,
9985 >,
9986 {
9987 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
9988 4781081784078915088,
9989 <super::GetChildOutputDictionary as ::fidl_next::Method>::FLEXIBILITY,
9990 request,
9991 ))
9992 }
9993 }
9994
9995 #[repr(transparent)]
9997 pub struct RealmServer<___T: ::fidl_next::Transport> {
9998 server: ::fidl_next::protocol::Server<___T>,
9999 }
10000
10001 impl<___T> RealmServer<___T> where ___T: ::fidl_next::Transport {}
10002 }
10003}
10004
10005pub trait RealmClientHandler<
10009 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10010 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10011>
10012{
10013}
10014
10015impl<___T> RealmClientHandler<___T> for ::fidl_next::IgnoreEvents where ___T: ::fidl_next::Transport {}
10016
10017impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Realm
10018where
10019 ___H: RealmClientHandler<___T> + ::core::marker::Send,
10020 ___T: ::fidl_next::Transport,
10021{
10022 async fn on_event(
10023 handler: &mut ___H,
10024 ordinal: u64,
10025 flexibility: ::fidl_next::protocol::Flexibility,
10026 body: ::fidl_next::Body<___T>,
10027 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10028 match ordinal {
10029 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
10030 }
10031 }
10032}
10033
10034pub trait RealmServerHandler<
10038 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10039 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10040>
10041{
10042 #[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"]
10043 fn open_controller(
10044 &mut self,
10045
10046 request: ::fidl_next::Request<realm::OpenController, ___T>,
10047
10048 responder: ::fidl_next::Responder<realm::OpenController, ___T>,
10049 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10050
10051 #[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"]
10052 fn open_exposed_dir(
10053 &mut self,
10054
10055 request: ::fidl_next::Request<realm::OpenExposedDir, ___T>,
10056
10057 responder: ::fidl_next::Responder<realm::OpenExposedDir, ___T>,
10058 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10059
10060 #[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"]
10061 fn create_child(
10062 &mut self,
10063
10064 request: ::fidl_next::Request<realm::CreateChild, ___T>,
10065
10066 responder: ::fidl_next::Responder<realm::CreateChild, ___T>,
10067 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10068
10069 #[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"]
10070 fn destroy_child(
10071 &mut self,
10072
10073 request: ::fidl_next::Request<realm::DestroyChild, ___T>,
10074
10075 responder: ::fidl_next::Responder<realm::DestroyChild, ___T>,
10076 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10077
10078 #[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"]
10079 fn list_children(
10080 &mut self,
10081
10082 request: ::fidl_next::Request<realm::ListChildren, ___T>,
10083
10084 responder: ::fidl_next::Responder<realm::ListChildren, ___T>,
10085 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10086
10087 #[doc = " Returns the set of information that was given to the component framework\n by this component\'s resolver.\n"]
10088 fn get_resolved_info(
10089 &mut self,
10090
10091 responder: ::fidl_next::Responder<realm::GetResolvedInfo, ___T>,
10092 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10093
10094 fn get_child_output_dictionary_deprecated(
10095 &mut self,
10096
10097 request: ::fidl_next::Request<realm::GetChildOutputDictionaryDeprecated, ___T>,
10098
10099 responder: ::fidl_next::Responder<realm::GetChildOutputDictionaryDeprecated, ___T>,
10100 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10101
10102 #[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"]
10103 fn get_child_output_dictionary(
10104 &mut self,
10105
10106 request: ::fidl_next::Request<realm::GetChildOutputDictionary, ___T>,
10107
10108 responder: ::fidl_next::Responder<realm::GetChildOutputDictionary, ___T>,
10109 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10110}
10111
10112impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Realm
10113where
10114 ___H: RealmServerHandler<___T> + ::core::marker::Send,
10115 ___T: ::fidl_next::Transport,
10116 for<'de> crate::wire::RealmOpenControllerRequest<'de>: ::fidl_next::Decode<
10117 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10118 Constraint = (),
10119 >,
10120 for<'de> crate::wire::RealmOpenExposedDirRequest<'de>: ::fidl_next::Decode<
10121 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10122 Constraint = (),
10123 >,
10124 for<'de> crate::wire::RealmCreateChildRequest<'de>: ::fidl_next::Decode<
10125 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10126 Constraint = (),
10127 >,
10128 for<'de> crate::wire::RealmDestroyChildRequest<'de>: ::fidl_next::Decode<
10129 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10130 Constraint = (),
10131 >,
10132 for<'de> crate::wire::RealmListChildrenRequest<'de>: ::fidl_next::Decode<
10133 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10134 Constraint = (),
10135 >,
10136 for<'de> crate::wire::RealmGetChildOutputDictionaryDeprecatedRequest<'de>: ::fidl_next::Decode<
10137 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10138 Constraint = (),
10139 >,
10140 for<'de> crate::wire::RealmGetChildOutputDictionaryRequest<'de>: ::fidl_next::Decode<
10141 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10142 Constraint = (),
10143 >,
10144{
10145 async fn on_one_way(
10146 handler: &mut ___H,
10147 ordinal: u64,
10148 flexibility: ::fidl_next::protocol::Flexibility,
10149 body: ::fidl_next::Body<___T>,
10150 ) -> ::core::result::Result<
10151 (),
10152 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10153 > {
10154 match ordinal {
10155 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
10156 }
10157 }
10158
10159 async fn on_two_way(
10160 handler: &mut ___H,
10161 ordinal: u64,
10162 flexibility: ::fidl_next::protocol::Flexibility,
10163 body: ::fidl_next::Body<___T>,
10164 responder: ::fidl_next::protocol::Responder<___T>,
10165 ) -> ::core::result::Result<
10166 (),
10167 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10168 > {
10169 match ordinal {
10170 8165227925828473216 => {
10171 let responder = ::fidl_next::Responder::from_untyped(responder);
10172
10173 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10174 Ok(decoded) => {
10175 handler
10176 .open_controller(::fidl_next::Request::from_decoded(decoded), responder)
10177 .await;
10178 Ok(())
10179 }
10180 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10181 ordinal: 8165227925828473216,
10182 error,
10183 }),
10184 }
10185 }
10186
10187 9194435320863127852 => {
10188 let responder = ::fidl_next::Responder::from_untyped(responder);
10189
10190 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10191 Ok(decoded) => {
10192 handler
10193 .open_exposed_dir(
10194 ::fidl_next::Request::from_decoded(decoded),
10195 responder,
10196 )
10197 .await;
10198 Ok(())
10199 }
10200 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10201 ordinal: 9194435320863127852,
10202 error,
10203 }),
10204 }
10205 }
10206
10207 4892190024503489888 => {
10208 let responder = ::fidl_next::Responder::from_untyped(responder);
10209
10210 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10211 Ok(decoded) => {
10212 handler
10213 .create_child(::fidl_next::Request::from_decoded(decoded), responder)
10214 .await;
10215 Ok(())
10216 }
10217 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10218 ordinal: 4892190024503489888,
10219 error,
10220 }),
10221 }
10222 }
10223
10224 8203529889988252194 => {
10225 let responder = ::fidl_next::Responder::from_untyped(responder);
10226
10227 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10228 Ok(decoded) => {
10229 handler
10230 .destroy_child(::fidl_next::Request::from_decoded(decoded), responder)
10231 .await;
10232 Ok(())
10233 }
10234 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10235 ordinal: 8203529889988252194,
10236 error,
10237 }),
10238 }
10239 }
10240
10241 7532454435519185057 => {
10242 let responder = ::fidl_next::Responder::from_untyped(responder);
10243
10244 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10245 Ok(decoded) => {
10246 handler
10247 .list_children(::fidl_next::Request::from_decoded(decoded), responder)
10248 .await;
10249 Ok(())
10250 }
10251 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10252 ordinal: 7532454435519185057,
10253 error,
10254 }),
10255 }
10256 }
10257
10258 8308987710372188322 => {
10259 let responder = ::fidl_next::Responder::from_untyped(responder);
10260
10261 handler.get_resolved_info(responder).await;
10262 Ok(())
10263 }
10264
10265 4117516026351534948 => {
10266 let responder = ::fidl_next::Responder::from_untyped(responder);
10267
10268 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10269 Ok(decoded) => {
10270 handler
10271 .get_child_output_dictionary_deprecated(
10272 ::fidl_next::Request::from_decoded(decoded),
10273 responder,
10274 )
10275 .await;
10276 Ok(())
10277 }
10278 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10279 ordinal: 4117516026351534948,
10280 error,
10281 }),
10282 }
10283 }
10284
10285 4781081784078915088 => {
10286 let responder = ::fidl_next::Responder::from_untyped(responder);
10287
10288 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10289 Ok(decoded) => {
10290 handler
10291 .get_child_output_dictionary(
10292 ::fidl_next::Request::from_decoded(decoded),
10293 responder,
10294 )
10295 .await;
10296 Ok(())
10297 }
10298 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10299 ordinal: 4781081784078915088,
10300 error,
10301 }),
10302 }
10303 }
10304
10305 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
10306 }
10307 }
10308}
10309
10310#[derive(PartialEq, Debug)]
10312pub struct StorageAdmin;
10313
10314impl ::fidl_next::Discoverable for StorageAdmin {
10315 const PROTOCOL_NAME: &'static str = "fuchsia.component.StorageAdmin";
10316}
10317
10318#[cfg(target_os = "fuchsia")]
10319impl ::fidl_next::HasTransport for StorageAdmin {
10320 type Transport = ::fidl_next::fuchsia::zx::Channel;
10321}
10322
10323pub mod storage_admin {
10324 pub mod prelude {
10325 pub use crate::{
10326 StorageAdmin, StorageAdminClientHandler, StorageAdminServerHandler, storage_admin,
10327 };
10328
10329 pub use crate::natural::DeletionError;
10330
10331 pub use crate::natural::Error;
10332
10333 pub use crate::natural::StatusError;
10334
10335 pub use crate::natural::StorageAdminDeleteComponentStorageRequest;
10336
10337 pub use crate::natural::StorageAdminListStorageInRealmRequest;
10338
10339 pub use crate::natural::StorageAdminOpenComponentStorageByIdRequest;
10340
10341 pub use crate::natural::StorageAdminOpenStorageRequest;
10342
10343 pub use crate::natural::StorageAdminDeleteAllStorageContentsResponse;
10344
10345 pub use crate::natural::StorageAdminDeleteComponentStorageResponse;
10346
10347 pub use crate::natural::StorageAdminListStorageInRealmResponse;
10348
10349 pub use crate::natural::StorageAdminOpenComponentStorageByIdResponse;
10350
10351 pub use crate::natural::StorageAdminOpenStorageResponse;
10352
10353 pub use crate::natural::StorageStatus;
10354 }
10355
10356 pub struct OpenStorage;
10357
10358 impl ::fidl_next::Method for OpenStorage {
10359 const ORDINAL: u64 = 7848267339832116087;
10360 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10361 ::fidl_next::protocol::Flexibility::Strict;
10362
10363 type Protocol = crate::StorageAdmin;
10364
10365 type Request = crate::wire::StorageAdminOpenStorageRequest<'static>;
10366 }
10367
10368 impl ::fidl_next::TwoWayMethod for OpenStorage {
10369 type Response = ::fidl_next::wire::Result<
10370 'static,
10371 crate::wire::StorageAdminOpenStorageResponse,
10372 crate::wire::Error,
10373 >;
10374 }
10375
10376 impl<___R> ::fidl_next::Respond<___R> for OpenStorage {
10377 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10378
10379 fn respond(response: ___R) -> Self::Output {
10380 ::core::result::Result::Ok(response)
10381 }
10382 }
10383
10384 impl<___R> ::fidl_next::RespondErr<___R> for OpenStorage {
10385 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10386
10387 fn respond_err(response: ___R) -> Self::Output {
10388 ::core::result::Result::Err(response)
10389 }
10390 }
10391
10392 pub struct ListStorageInRealm;
10393
10394 impl ::fidl_next::Method for ListStorageInRealm {
10395 const ORDINAL: u64 = 8525152599685368827;
10396 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10397 ::fidl_next::protocol::Flexibility::Strict;
10398
10399 type Protocol = crate::StorageAdmin;
10400
10401 type Request = crate::wire::StorageAdminListStorageInRealmRequest<'static>;
10402 }
10403
10404 impl ::fidl_next::TwoWayMethod for ListStorageInRealm {
10405 type Response = ::fidl_next::wire::Result<
10406 'static,
10407 crate::wire::StorageAdminListStorageInRealmResponse,
10408 crate::wire::Error,
10409 >;
10410 }
10411
10412 impl<___R> ::fidl_next::Respond<___R> for ListStorageInRealm {
10413 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10414
10415 fn respond(response: ___R) -> Self::Output {
10416 ::core::result::Result::Ok(response)
10417 }
10418 }
10419
10420 impl<___R> ::fidl_next::RespondErr<___R> for ListStorageInRealm {
10421 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10422
10423 fn respond_err(response: ___R) -> Self::Output {
10424 ::core::result::Result::Err(response)
10425 }
10426 }
10427
10428 pub struct OpenComponentStorageById;
10429
10430 impl ::fidl_next::Method for OpenComponentStorageById {
10431 const ORDINAL: u64 = 5188727505160068593;
10432 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10433 ::fidl_next::protocol::Flexibility::Strict;
10434
10435 type Protocol = crate::StorageAdmin;
10436
10437 type Request = crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>;
10438 }
10439
10440 impl ::fidl_next::TwoWayMethod for OpenComponentStorageById {
10441 type Response = ::fidl_next::wire::Result<
10442 'static,
10443 crate::wire::StorageAdminOpenComponentStorageByIdResponse,
10444 crate::wire::Error,
10445 >;
10446 }
10447
10448 impl<___R> ::fidl_next::Respond<___R> for OpenComponentStorageById {
10449 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10450
10451 fn respond(response: ___R) -> Self::Output {
10452 ::core::result::Result::Ok(response)
10453 }
10454 }
10455
10456 impl<___R> ::fidl_next::RespondErr<___R> for OpenComponentStorageById {
10457 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10458
10459 fn respond_err(response: ___R) -> Self::Output {
10460 ::core::result::Result::Err(response)
10461 }
10462 }
10463
10464 pub struct DeleteComponentStorage;
10465
10466 impl ::fidl_next::Method for DeleteComponentStorage {
10467 const ORDINAL: u64 = 1618975681517712474;
10468 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10469 ::fidl_next::protocol::Flexibility::Strict;
10470
10471 type Protocol = crate::StorageAdmin;
10472
10473 type Request = crate::wire::StorageAdminDeleteComponentStorageRequest<'static>;
10474 }
10475
10476 impl ::fidl_next::TwoWayMethod for DeleteComponentStorage {
10477 type Response = ::fidl_next::wire::Result<
10478 'static,
10479 crate::wire::StorageAdminDeleteComponentStorageResponse,
10480 crate::wire::Error,
10481 >;
10482 }
10483
10484 impl<___R> ::fidl_next::Respond<___R> for DeleteComponentStorage {
10485 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10486
10487 fn respond(response: ___R) -> Self::Output {
10488 ::core::result::Result::Ok(response)
10489 }
10490 }
10491
10492 impl<___R> ::fidl_next::RespondErr<___R> for DeleteComponentStorage {
10493 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10494
10495 fn respond_err(response: ___R) -> Self::Output {
10496 ::core::result::Result::Err(response)
10497 }
10498 }
10499
10500 pub struct GetStatus;
10501
10502 impl ::fidl_next::Method for GetStatus {
10503 const ORDINAL: u64 = 8586643915409794760;
10504 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10505 ::fidl_next::protocol::Flexibility::Strict;
10506
10507 type Protocol = crate::StorageAdmin;
10508
10509 type Request = ::fidl_next::wire::EmptyMessageBody;
10510 }
10511
10512 impl ::fidl_next::TwoWayMethod for GetStatus {
10513 type Response = ::fidl_next::wire::Result<
10514 'static,
10515 crate::wire::StorageStatus<'static>,
10516 crate::wire::StatusError,
10517 >;
10518 }
10519
10520 impl<___R> ::fidl_next::Respond<___R> for GetStatus {
10521 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10522
10523 fn respond(response: ___R) -> Self::Output {
10524 ::core::result::Result::Ok(response)
10525 }
10526 }
10527
10528 impl<___R> ::fidl_next::RespondErr<___R> for GetStatus {
10529 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10530
10531 fn respond_err(response: ___R) -> Self::Output {
10532 ::core::result::Result::Err(response)
10533 }
10534 }
10535
10536 pub struct DeleteAllStorageContents;
10537
10538 impl ::fidl_next::Method for DeleteAllStorageContents {
10539 const ORDINAL: u64 = 3380374508900862683;
10540 const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
10541 ::fidl_next::protocol::Flexibility::Strict;
10542
10543 type Protocol = crate::StorageAdmin;
10544
10545 type Request = ::fidl_next::wire::EmptyMessageBody;
10546 }
10547
10548 impl ::fidl_next::TwoWayMethod for DeleteAllStorageContents {
10549 type Response = ::fidl_next::wire::Result<
10550 'static,
10551 crate::wire::StorageAdminDeleteAllStorageContentsResponse,
10552 crate::wire::DeletionError,
10553 >;
10554 }
10555
10556 impl<___R> ::fidl_next::Respond<___R> for DeleteAllStorageContents {
10557 type Output = ::core::result::Result<___R, ::fidl_next::util::Never>;
10558
10559 fn respond(response: ___R) -> Self::Output {
10560 ::core::result::Result::Ok(response)
10561 }
10562 }
10563
10564 impl<___R> ::fidl_next::RespondErr<___R> for DeleteAllStorageContents {
10565 type Output = ::core::result::Result<::fidl_next::util::Never, ___R>;
10566
10567 fn respond_err(response: ___R) -> Self::Output {
10568 ::core::result::Result::Err(response)
10569 }
10570 }
10571
10572 mod ___detail {
10573 unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::StorageAdmin
10574 where
10575 ___T: ::fidl_next::Transport,
10576 {
10577 type Client = StorageAdminClient<___T>;
10578 type Server = StorageAdminServer<___T>;
10579 }
10580
10581 #[repr(transparent)]
10583 pub struct StorageAdminClient<___T: ::fidl_next::Transport> {
10584 #[allow(dead_code)]
10585 client: ::fidl_next::protocol::Client<___T>,
10586 }
10587
10588 impl<___T> StorageAdminClient<___T>
10589 where
10590 ___T: ::fidl_next::Transport,
10591 {
10592 #[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"]
10593 pub fn open_storage(
10594 &self,
10595
10596 relative_moniker: impl ::fidl_next::Encode<
10597 ::fidl_next::wire::String<'static>,
10598 <___T as ::fidl_next::Transport>::SendBuffer,
10599 >,
10600
10601 object: impl ::fidl_next::Encode<
10602 ::fidl_next::ServerEnd<
10603 ::fidl_next_fuchsia_io::Node,
10604 ::fidl_next::wire::fuchsia::Channel,
10605 >,
10606 <___T as ::fidl_next::Transport>::SendBuffer,
10607 >,
10608 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenStorage, ___T>
10609 where
10610 <___T as ::fidl_next::Transport>::SendBuffer:
10611 ::fidl_next::encoder::InternalHandleEncoder,
10612 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10613 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10614 {
10615 self.open_storage_with(crate::generic::StorageAdminOpenStorageRequest {
10616 relative_moniker,
10617
10618 object,
10619 })
10620 }
10621
10622 #[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"]
10623 pub fn open_storage_with<___R>(
10624 &self,
10625 request: ___R,
10626 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenStorage, ___T>
10627 where
10628 ___R: ::fidl_next::Encode<
10629 crate::wire::StorageAdminOpenStorageRequest<'static>,
10630 <___T as ::fidl_next::Transport>::SendBuffer,
10631 >,
10632 {
10633 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10634 7848267339832116087,
10635 <super::OpenStorage as ::fidl_next::Method>::FLEXIBILITY,
10636 request,
10637 ))
10638 }
10639
10640 #[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"]
10641 pub fn list_storage_in_realm(
10642 &self,
10643
10644 relative_moniker: impl ::fidl_next::Encode<
10645 ::fidl_next::wire::String<'static>,
10646 <___T as ::fidl_next::Transport>::SendBuffer,
10647 >,
10648
10649 iterator: impl ::fidl_next::Encode<
10650 ::fidl_next::ServerEnd<
10651 crate::StorageIterator,
10652 ::fidl_next::wire::fuchsia::Channel,
10653 >,
10654 <___T as ::fidl_next::Transport>::SendBuffer,
10655 >,
10656 ) -> ::fidl_next::TwoWayFuture<'_, super::ListStorageInRealm, ___T>
10657 where
10658 <___T as ::fidl_next::Transport>::SendBuffer:
10659 ::fidl_next::encoder::InternalHandleEncoder,
10660 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10661 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10662 {
10663 self.list_storage_in_realm_with(
10664 crate::generic::StorageAdminListStorageInRealmRequest {
10665 relative_moniker,
10666
10667 iterator,
10668 },
10669 )
10670 }
10671
10672 #[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"]
10673 pub fn list_storage_in_realm_with<___R>(
10674 &self,
10675 request: ___R,
10676 ) -> ::fidl_next::TwoWayFuture<'_, super::ListStorageInRealm, ___T>
10677 where
10678 ___R: ::fidl_next::Encode<
10679 crate::wire::StorageAdminListStorageInRealmRequest<'static>,
10680 <___T as ::fidl_next::Transport>::SendBuffer,
10681 >,
10682 {
10683 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10684 8525152599685368827,
10685 <super::ListStorageInRealm as ::fidl_next::Method>::FLEXIBILITY,
10686 request,
10687 ))
10688 }
10689
10690 #[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"]
10691 pub fn open_component_storage_by_id(
10692 &self,
10693
10694 id: impl ::fidl_next::Encode<
10695 ::fidl_next::wire::String<'static>,
10696 <___T as ::fidl_next::Transport>::SendBuffer,
10697 >,
10698
10699 object: impl ::fidl_next::Encode<
10700 ::fidl_next::ServerEnd<
10701 ::fidl_next_fuchsia_io::Node,
10702 ::fidl_next::wire::fuchsia::Channel,
10703 >,
10704 <___T as ::fidl_next::Transport>::SendBuffer,
10705 >,
10706 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenComponentStorageById, ___T>
10707 where
10708 <___T as ::fidl_next::Transport>::SendBuffer:
10709 ::fidl_next::encoder::InternalHandleEncoder,
10710 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10711 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
10712 {
10713 self.open_component_storage_by_id_with(
10714 crate::generic::StorageAdminOpenComponentStorageByIdRequest { id, object },
10715 )
10716 }
10717
10718 #[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"]
10719 pub fn open_component_storage_by_id_with<___R>(
10720 &self,
10721 request: ___R,
10722 ) -> ::fidl_next::TwoWayFuture<'_, super::OpenComponentStorageById, ___T>
10723 where
10724 ___R: ::fidl_next::Encode<
10725 crate::wire::StorageAdminOpenComponentStorageByIdRequest<'static>,
10726 <___T as ::fidl_next::Transport>::SendBuffer,
10727 >,
10728 {
10729 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10730 5188727505160068593,
10731 <super::OpenComponentStorageById as ::fidl_next::Method>::FLEXIBILITY,
10732 request,
10733 ))
10734 }
10735
10736 #[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"]
10737 pub fn delete_component_storage(
10738 &self,
10739
10740 relative_moniker: impl ::fidl_next::Encode<
10741 ::fidl_next::wire::String<'static>,
10742 <___T as ::fidl_next::Transport>::SendBuffer,
10743 >,
10744 ) -> ::fidl_next::TwoWayFuture<'_, super::DeleteComponentStorage, ___T>
10745 where
10746 <___T as ::fidl_next::Transport>::SendBuffer:
10747 ::fidl_next::encoder::InternalHandleEncoder,
10748 <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
10749 {
10750 self.delete_component_storage_with(
10751 crate::generic::StorageAdminDeleteComponentStorageRequest { relative_moniker },
10752 )
10753 }
10754
10755 #[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"]
10756 pub fn delete_component_storage_with<___R>(
10757 &self,
10758 request: ___R,
10759 ) -> ::fidl_next::TwoWayFuture<'_, super::DeleteComponentStorage, ___T>
10760 where
10761 ___R: ::fidl_next::Encode<
10762 crate::wire::StorageAdminDeleteComponentStorageRequest<'static>,
10763 <___T as ::fidl_next::Transport>::SendBuffer,
10764 >,
10765 {
10766 ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
10767 1618975681517712474,
10768 <super::DeleteComponentStorage as ::fidl_next::Method>::FLEXIBILITY,
10769 request,
10770 ))
10771 }
10772
10773 #[doc = " Get the current status of the storage.\n"]
10774 pub fn get_status(&self) -> ::fidl_next::TwoWayFuture<'_, super::GetStatus, ___T> {
10775 ::fidl_next::TwoWayFuture::from_untyped(
10776 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10777 8586643915409794760,
10778 <super::GetStatus as ::fidl_next::Method>::FLEXIBILITY,
10779 (),
10780 ),
10781 )
10782 }
10783
10784 #[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"]
10785 pub fn delete_all_storage_contents(
10786 &self,
10787 ) -> ::fidl_next::TwoWayFuture<'_, super::DeleteAllStorageContents, ___T> {
10788 ::fidl_next::TwoWayFuture::from_untyped(
10789 self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
10790 3380374508900862683,
10791 <super::DeleteAllStorageContents as ::fidl_next::Method>::FLEXIBILITY,
10792 (),
10793 ),
10794 )
10795 }
10796 }
10797
10798 #[repr(transparent)]
10800 pub struct StorageAdminServer<___T: ::fidl_next::Transport> {
10801 server: ::fidl_next::protocol::Server<___T>,
10802 }
10803
10804 impl<___T> StorageAdminServer<___T> where ___T: ::fidl_next::Transport {}
10805 }
10806}
10807
10808pub trait StorageAdminClientHandler<
10812 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10813 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10814>
10815{
10816}
10817
10818impl<___T> StorageAdminClientHandler<___T> for ::fidl_next::IgnoreEvents where
10819 ___T: ::fidl_next::Transport
10820{
10821}
10822
10823impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for StorageAdmin
10824where
10825 ___H: StorageAdminClientHandler<___T> + ::core::marker::Send,
10826 ___T: ::fidl_next::Transport,
10827{
10828 async fn on_event(
10829 handler: &mut ___H,
10830 ordinal: u64,
10831 flexibility: ::fidl_next::protocol::Flexibility,
10832 body: ::fidl_next::Body<___T>,
10833 ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
10834 match ordinal {
10835 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
10836 }
10837 }
10838}
10839
10840pub trait StorageAdminServerHandler<
10844 #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
10845 #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
10846>
10847{
10848 #[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"]
10849 fn open_storage(
10850 &mut self,
10851
10852 request: ::fidl_next::Request<storage_admin::OpenStorage, ___T>,
10853
10854 responder: ::fidl_next::Responder<storage_admin::OpenStorage, ___T>,
10855 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10856
10857 #[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"]
10858 fn list_storage_in_realm(
10859 &mut self,
10860
10861 request: ::fidl_next::Request<storage_admin::ListStorageInRealm, ___T>,
10862
10863 responder: ::fidl_next::Responder<storage_admin::ListStorageInRealm, ___T>,
10864 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10865
10866 #[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"]
10867 fn open_component_storage_by_id(
10868 &mut self,
10869
10870 request: ::fidl_next::Request<storage_admin::OpenComponentStorageById, ___T>,
10871
10872 responder: ::fidl_next::Responder<storage_admin::OpenComponentStorageById, ___T>,
10873 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10874
10875 #[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"]
10876 fn delete_component_storage(
10877 &mut self,
10878
10879 request: ::fidl_next::Request<storage_admin::DeleteComponentStorage, ___T>,
10880
10881 responder: ::fidl_next::Responder<storage_admin::DeleteComponentStorage, ___T>,
10882 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10883
10884 #[doc = " Get the current status of the storage.\n"]
10885 fn get_status(
10886 &mut self,
10887
10888 responder: ::fidl_next::Responder<storage_admin::GetStatus, ___T>,
10889 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10890
10891 #[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"]
10892 fn delete_all_storage_contents(
10893 &mut self,
10894
10895 responder: ::fidl_next::Responder<storage_admin::DeleteAllStorageContents, ___T>,
10896 ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
10897}
10898
10899impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for StorageAdmin
10900where
10901 ___H: StorageAdminServerHandler<___T> + ::core::marker::Send,
10902 ___T: ::fidl_next::Transport,
10903 for<'de> crate::wire::StorageAdminOpenStorageRequest<'de>: ::fidl_next::Decode<
10904 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10905 Constraint = (),
10906 >,
10907 for<'de> crate::wire::StorageAdminListStorageInRealmRequest<'de>: ::fidl_next::Decode<
10908 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10909 Constraint = (),
10910 >,
10911 for<'de> crate::wire::StorageAdminOpenComponentStorageByIdRequest<'de>: ::fidl_next::Decode<
10912 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10913 Constraint = (),
10914 >,
10915 for<'de> crate::wire::StorageAdminDeleteComponentStorageRequest<'de>: ::fidl_next::Decode<
10916 <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
10917 Constraint = (),
10918 >,
10919{
10920 async fn on_one_way(
10921 handler: &mut ___H,
10922 ordinal: u64,
10923 flexibility: ::fidl_next::protocol::Flexibility,
10924 body: ::fidl_next::Body<___T>,
10925 ) -> ::core::result::Result<
10926 (),
10927 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10928 > {
10929 match ordinal {
10930 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
10931 }
10932 }
10933
10934 async fn on_two_way(
10935 handler: &mut ___H,
10936 ordinal: u64,
10937 flexibility: ::fidl_next::protocol::Flexibility,
10938 body: ::fidl_next::Body<___T>,
10939 responder: ::fidl_next::protocol::Responder<___T>,
10940 ) -> ::core::result::Result<
10941 (),
10942 ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
10943 > {
10944 match ordinal {
10945 7848267339832116087 => {
10946 let responder = ::fidl_next::Responder::from_untyped(responder);
10947
10948 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10949 Ok(decoded) => {
10950 handler
10951 .open_storage(::fidl_next::Request::from_decoded(decoded), responder)
10952 .await;
10953 Ok(())
10954 }
10955 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10956 ordinal: 7848267339832116087,
10957 error,
10958 }),
10959 }
10960 }
10961
10962 8525152599685368827 => {
10963 let responder = ::fidl_next::Responder::from_untyped(responder);
10964
10965 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10966 Ok(decoded) => {
10967 handler
10968 .list_storage_in_realm(
10969 ::fidl_next::Request::from_decoded(decoded),
10970 responder,
10971 )
10972 .await;
10973 Ok(())
10974 }
10975 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10976 ordinal: 8525152599685368827,
10977 error,
10978 }),
10979 }
10980 }
10981
10982 5188727505160068593 => {
10983 let responder = ::fidl_next::Responder::from_untyped(responder);
10984
10985 match ::fidl_next::AsDecoderExt::into_decoded(body) {
10986 Ok(decoded) => {
10987 handler
10988 .open_component_storage_by_id(
10989 ::fidl_next::Request::from_decoded(decoded),
10990 responder,
10991 )
10992 .await;
10993 Ok(())
10994 }
10995 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
10996 ordinal: 5188727505160068593,
10997 error,
10998 }),
10999 }
11000 }
11001
11002 1618975681517712474 => {
11003 let responder = ::fidl_next::Responder::from_untyped(responder);
11004
11005 match ::fidl_next::AsDecoderExt::into_decoded(body) {
11006 Ok(decoded) => {
11007 handler
11008 .delete_component_storage(
11009 ::fidl_next::Request::from_decoded(decoded),
11010 responder,
11011 )
11012 .await;
11013 Ok(())
11014 }
11015 Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
11016 ordinal: 1618975681517712474,
11017 error,
11018 }),
11019 }
11020 }
11021
11022 8586643915409794760 => {
11023 let responder = ::fidl_next::Responder::from_untyped(responder);
11024
11025 handler.get_status(responder).await;
11026 Ok(())
11027 }
11028
11029 3380374508900862683 => {
11030 let responder = ::fidl_next::Responder::from_untyped(responder);
11031
11032 handler.delete_all_storage_contents(responder).await;
11033 Ok(())
11034 }
11035
11036 ordinal => Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal)),
11037 }
11038 }
11039}
11040
11041pub use fidl_next_common_fuchsia_component::*;