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