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