fidl_fuchsia_starnix_runner/
fidl_fuchsia_starnix_runner.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10pub use fidl_fuchsia_starnix_runner__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Default, PartialEq)]
15pub struct ManagerCreatePagerRequest {
16    /// The backing vmo to use in the pager.
17    pub backing_vmo: Option<fidl::Vmo>,
18    /// The block size for the pager to use.
19    pub block_size: Option<u64>,
20    /// The `Pager` instance that will serve the pager requests.
21    pub pager: Option<fidl::endpoints::ServerEnd<PagerMarker>>,
22    #[doc(hidden)]
23    pub __source_breaking: fidl::marker::SourceBreaking,
24}
25
26impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ManagerCreatePagerRequest {}
27
28#[derive(Debug, Default, PartialEq)]
29pub struct ManagerProxyWakeChannelRequest {
30    /// The job of the container that holds the other end of `container_channel`.
31    pub container_job: Option<fidl::Job>,
32    /// The channel endpoint that is connected to the container.
33    pub container_channel: Option<fidl::Channel>,
34    /// The channel endpoint that is connected to a component outside the container.
35    pub remote_channel: Option<fidl::Channel>,
36    /// The name of the proxy, used for debugging purposes.
37    pub name: Option<String>,
38    /// A counter that is used to count how many unhandled requests have been sent to the
39    /// container. If this counter is non-zero, the container will not be able to suspend.
40    ///
41    /// Each time the client handles a message on the proxied channel, it is expected to
42    /// decrement the counter by 1. This decrement should only happen once the client is
43    /// ready to allow suspension. Often this means that a new hanging get has been sent on
44    /// the proxied channel.
45    pub counter: Option<fidl::Counter>,
46    #[doc(hidden)]
47    pub __source_breaking: fidl::marker::SourceBreaking,
48}
49
50impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
51    for ManagerProxyWakeChannelRequest
52{
53}
54
55#[derive(Debug, Default, PartialEq)]
56pub struct ManagerRegisterWakeWatcherRequest {
57    /// The event that will be signaled when the container's wake status changes.
58    pub watcher: Option<fidl::EventPair>,
59    #[doc(hidden)]
60    pub __source_breaking: fidl::marker::SourceBreaking,
61}
62
63impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
64    for ManagerRegisterWakeWatcherRequest
65{
66}
67
68#[derive(Debug, Default, PartialEq)]
69pub struct ManagerSuspendContainerRequest {
70    /// The job of the container to suspend.
71    pub container_job: Option<fidl::Job>,
72    /// The event that is used to signal whether or not there are any active wake locks
73    /// in the container.
74    pub wake_locks: Option<fidl::EventPair>,
75    #[doc(hidden)]
76    pub __source_breaking: fidl::marker::SourceBreaking,
77}
78
79impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
80    for ManagerSuspendContainerRequest
81{
82}
83
84#[derive(Debug, Default, PartialEq)]
85pub struct PagerRegisterFileResponse {
86    /// A newly created child vmo.
87    pub vmo: Option<fidl::Vmo>,
88    #[doc(hidden)]
89    pub __source_breaking: fidl::marker::SourceBreaking,
90}
91
92impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for PagerRegisterFileResponse {}
93
94#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
95pub struct ManagerMarker;
96
97impl fidl::endpoints::ProtocolMarker for ManagerMarker {
98    type Proxy = ManagerProxy;
99    type RequestStream = ManagerRequestStream;
100    #[cfg(target_os = "fuchsia")]
101    type SynchronousProxy = ManagerSynchronousProxy;
102
103    const DEBUG_NAME: &'static str = "fuchsia.starnix.runner.Manager";
104}
105impl fidl::endpoints::DiscoverableProtocolMarker for ManagerMarker {}
106pub type ManagerSuspendContainerResult = Result<ManagerSuspendContainerResponse, SuspendError>;
107
108pub trait ManagerProxyInterface: Send + Sync {
109    type SuspendContainerResponseFut: std::future::Future<Output = Result<ManagerSuspendContainerResult, fidl::Error>>
110        + Send;
111    fn r#suspend_container(
112        &self,
113        payload: ManagerSuspendContainerRequest,
114    ) -> Self::SuspendContainerResponseFut;
115    fn r#proxy_wake_channel(
116        &self,
117        payload: ManagerProxyWakeChannelRequest,
118    ) -> Result<(), fidl::Error>;
119    type RegisterWakeWatcherResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
120        + Send;
121    fn r#register_wake_watcher(
122        &self,
123        payload: ManagerRegisterWakeWatcherRequest,
124    ) -> Self::RegisterWakeWatcherResponseFut;
125    fn r#create_pager(&self, payload: ManagerCreatePagerRequest) -> Result<(), fidl::Error>;
126}
127#[derive(Debug)]
128#[cfg(target_os = "fuchsia")]
129pub struct ManagerSynchronousProxy {
130    client: fidl::client::sync::Client,
131}
132
133#[cfg(target_os = "fuchsia")]
134impl fidl::endpoints::SynchronousProxy for ManagerSynchronousProxy {
135    type Proxy = ManagerProxy;
136    type Protocol = ManagerMarker;
137
138    fn from_channel(inner: fidl::Channel) -> Self {
139        Self::new(inner)
140    }
141
142    fn into_channel(self) -> fidl::Channel {
143        self.client.into_channel()
144    }
145
146    fn as_channel(&self) -> &fidl::Channel {
147        self.client.as_channel()
148    }
149}
150
151#[cfg(target_os = "fuchsia")]
152impl ManagerSynchronousProxy {
153    pub fn new(channel: fidl::Channel) -> Self {
154        let protocol_name = <ManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
155        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
156    }
157
158    pub fn into_channel(self) -> fidl::Channel {
159        self.client.into_channel()
160    }
161
162    /// Waits until an event arrives and returns it. It is safe for other
163    /// threads to make concurrent requests while waiting for an event.
164    pub fn wait_for_event(
165        &self,
166        deadline: zx::MonotonicInstant,
167    ) -> Result<ManagerEvent, fidl::Error> {
168        ManagerEvent::decode(self.client.wait_for_event(deadline)?)
169    }
170
171    /// Suspends the container running in `job`.
172    ///
173    /// The call will return successfully when `wake_event` has been signaled. Returns
174    /// an error if `wake_locks` is signaled at the end of suspension, or an error is
175    /// encountered when suspending the container's processes.
176    pub fn r#suspend_container(
177        &self,
178        mut payload: ManagerSuspendContainerRequest,
179        ___deadline: zx::MonotonicInstant,
180    ) -> Result<ManagerSuspendContainerResult, fidl::Error> {
181        let _response = self.client.send_query::<
182            ManagerSuspendContainerRequest,
183            fidl::encoding::FlexibleResultType<ManagerSuspendContainerResponse, SuspendError>,
184        >(
185            &mut payload,
186            0x928527927c9f2a7,
187            fidl::encoding::DynamicFlags::FLEXIBLE,
188            ___deadline,
189        )?
190        .into_result::<ManagerMarker>("suspend_container")?;
191        Ok(_response.map(|x| x))
192    }
193
194    /// Creates a pass-through proxy that forwards messages between the `container_channel` and the
195    /// `remote_channel`.
196    ///
197    /// If any messages arrive on `remote_channel` while the container is suspended via
198    /// `SuspendContainer`, the container will be resumed and `counter` will be incremented.
199    ///
200    /// Once that message is handled by the container, and it's ok to suspend the container again
201    /// (relative to that message), the counter is expected to be decremented.
202    pub fn r#proxy_wake_channel(
203        &self,
204        mut payload: ManagerProxyWakeChannelRequest,
205    ) -> Result<(), fidl::Error> {
206        self.client.send::<ManagerProxyWakeChannelRequest>(
207            &mut payload,
208            0x46a374ab73b23714,
209            fidl::encoding::DynamicFlags::FLEXIBLE,
210        )
211    }
212
213    /// Registers an eventpair that will be signaled when the container is suspended or resumed.
214    /// The signals are ASLEEP(USER_1) and AWAKE(USER_0).
215    ///
216    /// The kernel returns AWAKE upon initial registration of the eventpair.
217    pub fn r#register_wake_watcher(
218        &self,
219        mut payload: ManagerRegisterWakeWatcherRequest,
220        ___deadline: zx::MonotonicInstant,
221    ) -> Result<(), fidl::Error> {
222        let _response = self.client.send_query::<
223            ManagerRegisterWakeWatcherRequest,
224            fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
225        >(
226            &mut payload,
227            0x456d74519eb65b41,
228            fidl::encoding::DynamicFlags::FLEXIBLE,
229            ___deadline,
230        )?
231        .into_result::<ManagerMarker>("register_wake_watcher")?;
232        Ok(_response)
233    }
234
235    /// Creates a `Pager` instance with the provided `backing_vmo` and `block_size`.
236    pub fn r#create_pager(
237        &self,
238        mut payload: ManagerCreatePagerRequest,
239    ) -> Result<(), fidl::Error> {
240        self.client.send::<ManagerCreatePagerRequest>(
241            &mut payload,
242            0x49d14958b736198b,
243            fidl::encoding::DynamicFlags::FLEXIBLE,
244        )
245    }
246}
247
248#[cfg(target_os = "fuchsia")]
249impl From<ManagerSynchronousProxy> for zx::Handle {
250    fn from(value: ManagerSynchronousProxy) -> Self {
251        value.into_channel().into()
252    }
253}
254
255#[cfg(target_os = "fuchsia")]
256impl From<fidl::Channel> for ManagerSynchronousProxy {
257    fn from(value: fidl::Channel) -> Self {
258        Self::new(value)
259    }
260}
261
262#[derive(Debug, Clone)]
263pub struct ManagerProxy {
264    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
265}
266
267impl fidl::endpoints::Proxy for ManagerProxy {
268    type Protocol = ManagerMarker;
269
270    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
271        Self::new(inner)
272    }
273
274    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
275        self.client.into_channel().map_err(|client| Self { client })
276    }
277
278    fn as_channel(&self) -> &::fidl::AsyncChannel {
279        self.client.as_channel()
280    }
281}
282
283impl ManagerProxy {
284    /// Create a new Proxy for fuchsia.starnix.runner/Manager.
285    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
286        let protocol_name = <ManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
287        Self { client: fidl::client::Client::new(channel, protocol_name) }
288    }
289
290    /// Get a Stream of events from the remote end of the protocol.
291    ///
292    /// # Panics
293    ///
294    /// Panics if the event stream was already taken.
295    pub fn take_event_stream(&self) -> ManagerEventStream {
296        ManagerEventStream { event_receiver: self.client.take_event_receiver() }
297    }
298
299    /// Suspends the container running in `job`.
300    ///
301    /// The call will return successfully when `wake_event` has been signaled. Returns
302    /// an error if `wake_locks` is signaled at the end of suspension, or an error is
303    /// encountered when suspending the container's processes.
304    pub fn r#suspend_container(
305        &self,
306        mut payload: ManagerSuspendContainerRequest,
307    ) -> fidl::client::QueryResponseFut<
308        ManagerSuspendContainerResult,
309        fidl::encoding::DefaultFuchsiaResourceDialect,
310    > {
311        ManagerProxyInterface::r#suspend_container(self, payload)
312    }
313
314    /// Creates a pass-through proxy that forwards messages between the `container_channel` and the
315    /// `remote_channel`.
316    ///
317    /// If any messages arrive on `remote_channel` while the container is suspended via
318    /// `SuspendContainer`, the container will be resumed and `counter` will be incremented.
319    ///
320    /// Once that message is handled by the container, and it's ok to suspend the container again
321    /// (relative to that message), the counter is expected to be decremented.
322    pub fn r#proxy_wake_channel(
323        &self,
324        mut payload: ManagerProxyWakeChannelRequest,
325    ) -> Result<(), fidl::Error> {
326        ManagerProxyInterface::r#proxy_wake_channel(self, payload)
327    }
328
329    /// Registers an eventpair that will be signaled when the container is suspended or resumed.
330    /// The signals are ASLEEP(USER_1) and AWAKE(USER_0).
331    ///
332    /// The kernel returns AWAKE upon initial registration of the eventpair.
333    pub fn r#register_wake_watcher(
334        &self,
335        mut payload: ManagerRegisterWakeWatcherRequest,
336    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
337        ManagerProxyInterface::r#register_wake_watcher(self, payload)
338    }
339
340    /// Creates a `Pager` instance with the provided `backing_vmo` and `block_size`.
341    pub fn r#create_pager(
342        &self,
343        mut payload: ManagerCreatePagerRequest,
344    ) -> Result<(), fidl::Error> {
345        ManagerProxyInterface::r#create_pager(self, payload)
346    }
347}
348
349impl ManagerProxyInterface for ManagerProxy {
350    type SuspendContainerResponseFut = fidl::client::QueryResponseFut<
351        ManagerSuspendContainerResult,
352        fidl::encoding::DefaultFuchsiaResourceDialect,
353    >;
354    fn r#suspend_container(
355        &self,
356        mut payload: ManagerSuspendContainerRequest,
357    ) -> Self::SuspendContainerResponseFut {
358        fn _decode(
359            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
360        ) -> Result<ManagerSuspendContainerResult, fidl::Error> {
361            let _response = fidl::client::decode_transaction_body::<
362                fidl::encoding::FlexibleResultType<ManagerSuspendContainerResponse, SuspendError>,
363                fidl::encoding::DefaultFuchsiaResourceDialect,
364                0x928527927c9f2a7,
365            >(_buf?)?
366            .into_result::<ManagerMarker>("suspend_container")?;
367            Ok(_response.map(|x| x))
368        }
369        self.client
370            .send_query_and_decode::<ManagerSuspendContainerRequest, ManagerSuspendContainerResult>(
371                &mut payload,
372                0x928527927c9f2a7,
373                fidl::encoding::DynamicFlags::FLEXIBLE,
374                _decode,
375            )
376    }
377
378    fn r#proxy_wake_channel(
379        &self,
380        mut payload: ManagerProxyWakeChannelRequest,
381    ) -> Result<(), fidl::Error> {
382        self.client.send::<ManagerProxyWakeChannelRequest>(
383            &mut payload,
384            0x46a374ab73b23714,
385            fidl::encoding::DynamicFlags::FLEXIBLE,
386        )
387    }
388
389    type RegisterWakeWatcherResponseFut =
390        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
391    fn r#register_wake_watcher(
392        &self,
393        mut payload: ManagerRegisterWakeWatcherRequest,
394    ) -> Self::RegisterWakeWatcherResponseFut {
395        fn _decode(
396            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
397        ) -> Result<(), fidl::Error> {
398            let _response = fidl::client::decode_transaction_body::<
399                fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>,
400                fidl::encoding::DefaultFuchsiaResourceDialect,
401                0x456d74519eb65b41,
402            >(_buf?)?
403            .into_result::<ManagerMarker>("register_wake_watcher")?;
404            Ok(_response)
405        }
406        self.client.send_query_and_decode::<ManagerRegisterWakeWatcherRequest, ()>(
407            &mut payload,
408            0x456d74519eb65b41,
409            fidl::encoding::DynamicFlags::FLEXIBLE,
410            _decode,
411        )
412    }
413
414    fn r#create_pager(&self, mut payload: ManagerCreatePagerRequest) -> Result<(), fidl::Error> {
415        self.client.send::<ManagerCreatePagerRequest>(
416            &mut payload,
417            0x49d14958b736198b,
418            fidl::encoding::DynamicFlags::FLEXIBLE,
419        )
420    }
421}
422
423pub struct ManagerEventStream {
424    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
425}
426
427impl std::marker::Unpin for ManagerEventStream {}
428
429impl futures::stream::FusedStream for ManagerEventStream {
430    fn is_terminated(&self) -> bool {
431        self.event_receiver.is_terminated()
432    }
433}
434
435impl futures::Stream for ManagerEventStream {
436    type Item = Result<ManagerEvent, fidl::Error>;
437
438    fn poll_next(
439        mut self: std::pin::Pin<&mut Self>,
440        cx: &mut std::task::Context<'_>,
441    ) -> std::task::Poll<Option<Self::Item>> {
442        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
443            &mut self.event_receiver,
444            cx
445        )?) {
446            Some(buf) => std::task::Poll::Ready(Some(ManagerEvent::decode(buf))),
447            None => std::task::Poll::Ready(None),
448        }
449    }
450}
451
452#[derive(Debug)]
453pub enum ManagerEvent {
454    #[non_exhaustive]
455    _UnknownEvent {
456        /// Ordinal of the event that was sent.
457        ordinal: u64,
458    },
459}
460
461impl ManagerEvent {
462    /// Decodes a message buffer as a [`ManagerEvent`].
463    fn decode(
464        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
465    ) -> Result<ManagerEvent, fidl::Error> {
466        let (bytes, _handles) = buf.split_mut();
467        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
468        debug_assert_eq!(tx_header.tx_id, 0);
469        match tx_header.ordinal {
470            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
471                Ok(ManagerEvent::_UnknownEvent { ordinal: tx_header.ordinal })
472            }
473            _ => Err(fidl::Error::UnknownOrdinal {
474                ordinal: tx_header.ordinal,
475                protocol_name: <ManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
476            }),
477        }
478    }
479}
480
481/// A Stream of incoming requests for fuchsia.starnix.runner/Manager.
482pub struct ManagerRequestStream {
483    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
484    is_terminated: bool,
485}
486
487impl std::marker::Unpin for ManagerRequestStream {}
488
489impl futures::stream::FusedStream for ManagerRequestStream {
490    fn is_terminated(&self) -> bool {
491        self.is_terminated
492    }
493}
494
495impl fidl::endpoints::RequestStream for ManagerRequestStream {
496    type Protocol = ManagerMarker;
497    type ControlHandle = ManagerControlHandle;
498
499    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
500        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
501    }
502
503    fn control_handle(&self) -> Self::ControlHandle {
504        ManagerControlHandle { inner: self.inner.clone() }
505    }
506
507    fn into_inner(
508        self,
509    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
510    {
511        (self.inner, self.is_terminated)
512    }
513
514    fn from_inner(
515        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
516        is_terminated: bool,
517    ) -> Self {
518        Self { inner, is_terminated }
519    }
520}
521
522impl futures::Stream for ManagerRequestStream {
523    type Item = Result<ManagerRequest, fidl::Error>;
524
525    fn poll_next(
526        mut self: std::pin::Pin<&mut Self>,
527        cx: &mut std::task::Context<'_>,
528    ) -> std::task::Poll<Option<Self::Item>> {
529        let this = &mut *self;
530        if this.inner.check_shutdown(cx) {
531            this.is_terminated = true;
532            return std::task::Poll::Ready(None);
533        }
534        if this.is_terminated {
535            panic!("polled ManagerRequestStream after completion");
536        }
537        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
538            |bytes, handles| {
539                match this.inner.channel().read_etc(cx, bytes, handles) {
540                    std::task::Poll::Ready(Ok(())) => {}
541                    std::task::Poll::Pending => return std::task::Poll::Pending,
542                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
543                        this.is_terminated = true;
544                        return std::task::Poll::Ready(None);
545                    }
546                    std::task::Poll::Ready(Err(e)) => {
547                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
548                            e.into(),
549                        ))))
550                    }
551                }
552
553                // A message has been received from the channel
554                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
555
556                std::task::Poll::Ready(Some(match header.ordinal {
557                    0x928527927c9f2a7 => {
558                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
559                        let mut req = fidl::new_empty!(
560                            ManagerSuspendContainerRequest,
561                            fidl::encoding::DefaultFuchsiaResourceDialect
562                        );
563                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ManagerSuspendContainerRequest>(&header, _body_bytes, handles, &mut req)?;
564                        let control_handle = ManagerControlHandle { inner: this.inner.clone() };
565                        Ok(ManagerRequest::SuspendContainer {
566                            payload: req,
567                            responder: ManagerSuspendContainerResponder {
568                                control_handle: std::mem::ManuallyDrop::new(control_handle),
569                                tx_id: header.tx_id,
570                            },
571                        })
572                    }
573                    0x46a374ab73b23714 => {
574                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
575                        let mut req = fidl::new_empty!(
576                            ManagerProxyWakeChannelRequest,
577                            fidl::encoding::DefaultFuchsiaResourceDialect
578                        );
579                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ManagerProxyWakeChannelRequest>(&header, _body_bytes, handles, &mut req)?;
580                        let control_handle = ManagerControlHandle { inner: this.inner.clone() };
581                        Ok(ManagerRequest::ProxyWakeChannel { payload: req, control_handle })
582                    }
583                    0x456d74519eb65b41 => {
584                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
585                        let mut req = fidl::new_empty!(
586                            ManagerRegisterWakeWatcherRequest,
587                            fidl::encoding::DefaultFuchsiaResourceDialect
588                        );
589                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ManagerRegisterWakeWatcherRequest>(&header, _body_bytes, handles, &mut req)?;
590                        let control_handle = ManagerControlHandle { inner: this.inner.clone() };
591                        Ok(ManagerRequest::RegisterWakeWatcher {
592                            payload: req,
593                            responder: ManagerRegisterWakeWatcherResponder {
594                                control_handle: std::mem::ManuallyDrop::new(control_handle),
595                                tx_id: header.tx_id,
596                            },
597                        })
598                    }
599                    0x49d14958b736198b => {
600                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
601                        let mut req = fidl::new_empty!(
602                            ManagerCreatePagerRequest,
603                            fidl::encoding::DefaultFuchsiaResourceDialect
604                        );
605                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ManagerCreatePagerRequest>(&header, _body_bytes, handles, &mut req)?;
606                        let control_handle = ManagerControlHandle { inner: this.inner.clone() };
607                        Ok(ManagerRequest::CreatePager { payload: req, control_handle })
608                    }
609                    _ if header.tx_id == 0
610                        && header
611                            .dynamic_flags()
612                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
613                    {
614                        Ok(ManagerRequest::_UnknownMethod {
615                            ordinal: header.ordinal,
616                            control_handle: ManagerControlHandle { inner: this.inner.clone() },
617                            method_type: fidl::MethodType::OneWay,
618                        })
619                    }
620                    _ if header
621                        .dynamic_flags()
622                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
623                    {
624                        this.inner.send_framework_err(
625                            fidl::encoding::FrameworkErr::UnknownMethod,
626                            header.tx_id,
627                            header.ordinal,
628                            header.dynamic_flags(),
629                            (bytes, handles),
630                        )?;
631                        Ok(ManagerRequest::_UnknownMethod {
632                            ordinal: header.ordinal,
633                            control_handle: ManagerControlHandle { inner: this.inner.clone() },
634                            method_type: fidl::MethodType::TwoWay,
635                        })
636                    }
637                    _ => Err(fidl::Error::UnknownOrdinal {
638                        ordinal: header.ordinal,
639                        protocol_name:
640                            <ManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
641                    }),
642                }))
643            },
644        )
645    }
646}
647
648#[derive(Debug)]
649pub enum ManagerRequest {
650    /// Suspends the container running in `job`.
651    ///
652    /// The call will return successfully when `wake_event` has been signaled. Returns
653    /// an error if `wake_locks` is signaled at the end of suspension, or an error is
654    /// encountered when suspending the container's processes.
655    SuspendContainer {
656        payload: ManagerSuspendContainerRequest,
657        responder: ManagerSuspendContainerResponder,
658    },
659    /// Creates a pass-through proxy that forwards messages between the `container_channel` and the
660    /// `remote_channel`.
661    ///
662    /// If any messages arrive on `remote_channel` while the container is suspended via
663    /// `SuspendContainer`, the container will be resumed and `counter` will be incremented.
664    ///
665    /// Once that message is handled by the container, and it's ok to suspend the container again
666    /// (relative to that message), the counter is expected to be decremented.
667    ProxyWakeChannel {
668        payload: ManagerProxyWakeChannelRequest,
669        control_handle: ManagerControlHandle,
670    },
671    /// Registers an eventpair that will be signaled when the container is suspended or resumed.
672    /// The signals are ASLEEP(USER_1) and AWAKE(USER_0).
673    ///
674    /// The kernel returns AWAKE upon initial registration of the eventpair.
675    RegisterWakeWatcher {
676        payload: ManagerRegisterWakeWatcherRequest,
677        responder: ManagerRegisterWakeWatcherResponder,
678    },
679    /// Creates a `Pager` instance with the provided `backing_vmo` and `block_size`.
680    CreatePager { payload: ManagerCreatePagerRequest, control_handle: ManagerControlHandle },
681    /// An interaction was received which does not match any known method.
682    #[non_exhaustive]
683    _UnknownMethod {
684        /// Ordinal of the method that was called.
685        ordinal: u64,
686        control_handle: ManagerControlHandle,
687        method_type: fidl::MethodType,
688    },
689}
690
691impl ManagerRequest {
692    #[allow(irrefutable_let_patterns)]
693    pub fn into_suspend_container(
694        self,
695    ) -> Option<(ManagerSuspendContainerRequest, ManagerSuspendContainerResponder)> {
696        if let ManagerRequest::SuspendContainer { payload, responder } = self {
697            Some((payload, responder))
698        } else {
699            None
700        }
701    }
702
703    #[allow(irrefutable_let_patterns)]
704    pub fn into_proxy_wake_channel(
705        self,
706    ) -> Option<(ManagerProxyWakeChannelRequest, ManagerControlHandle)> {
707        if let ManagerRequest::ProxyWakeChannel { payload, control_handle } = self {
708            Some((payload, control_handle))
709        } else {
710            None
711        }
712    }
713
714    #[allow(irrefutable_let_patterns)]
715    pub fn into_register_wake_watcher(
716        self,
717    ) -> Option<(ManagerRegisterWakeWatcherRequest, ManagerRegisterWakeWatcherResponder)> {
718        if let ManagerRequest::RegisterWakeWatcher { payload, responder } = self {
719            Some((payload, responder))
720        } else {
721            None
722        }
723    }
724
725    #[allow(irrefutable_let_patterns)]
726    pub fn into_create_pager(self) -> Option<(ManagerCreatePagerRequest, ManagerControlHandle)> {
727        if let ManagerRequest::CreatePager { payload, control_handle } = self {
728            Some((payload, control_handle))
729        } else {
730            None
731        }
732    }
733
734    /// Name of the method defined in FIDL
735    pub fn method_name(&self) -> &'static str {
736        match *self {
737            ManagerRequest::SuspendContainer { .. } => "suspend_container",
738            ManagerRequest::ProxyWakeChannel { .. } => "proxy_wake_channel",
739            ManagerRequest::RegisterWakeWatcher { .. } => "register_wake_watcher",
740            ManagerRequest::CreatePager { .. } => "create_pager",
741            ManagerRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
742                "unknown one-way method"
743            }
744            ManagerRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
745                "unknown two-way method"
746            }
747        }
748    }
749}
750
751#[derive(Debug, Clone)]
752pub struct ManagerControlHandle {
753    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
754}
755
756impl fidl::endpoints::ControlHandle for ManagerControlHandle {
757    fn shutdown(&self) {
758        self.inner.shutdown()
759    }
760    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
761        self.inner.shutdown_with_epitaph(status)
762    }
763
764    fn is_closed(&self) -> bool {
765        self.inner.channel().is_closed()
766    }
767    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
768        self.inner.channel().on_closed()
769    }
770
771    #[cfg(target_os = "fuchsia")]
772    fn signal_peer(
773        &self,
774        clear_mask: zx::Signals,
775        set_mask: zx::Signals,
776    ) -> Result<(), zx_status::Status> {
777        use fidl::Peered;
778        self.inner.channel().signal_peer(clear_mask, set_mask)
779    }
780}
781
782impl ManagerControlHandle {}
783
784#[must_use = "FIDL methods require a response to be sent"]
785#[derive(Debug)]
786pub struct ManagerSuspendContainerResponder {
787    control_handle: std::mem::ManuallyDrop<ManagerControlHandle>,
788    tx_id: u32,
789}
790
791/// Set the the channel to be shutdown (see [`ManagerControlHandle::shutdown`])
792/// if the responder is dropped without sending a response, so that the client
793/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
794impl std::ops::Drop for ManagerSuspendContainerResponder {
795    fn drop(&mut self) {
796        self.control_handle.shutdown();
797        // Safety: drops once, never accessed again
798        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
799    }
800}
801
802impl fidl::endpoints::Responder for ManagerSuspendContainerResponder {
803    type ControlHandle = ManagerControlHandle;
804
805    fn control_handle(&self) -> &ManagerControlHandle {
806        &self.control_handle
807    }
808
809    fn drop_without_shutdown(mut self) {
810        // Safety: drops once, never accessed again due to mem::forget
811        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
812        // Prevent Drop from running (which would shut down the channel)
813        std::mem::forget(self);
814    }
815}
816
817impl ManagerSuspendContainerResponder {
818    /// Sends a response to the FIDL transaction.
819    ///
820    /// Sets the channel to shutdown if an error occurs.
821    pub fn send(
822        self,
823        mut result: Result<&ManagerSuspendContainerResponse, SuspendError>,
824    ) -> Result<(), fidl::Error> {
825        let _result = self.send_raw(result);
826        if _result.is_err() {
827            self.control_handle.shutdown();
828        }
829        self.drop_without_shutdown();
830        _result
831    }
832
833    /// Similar to "send" but does not shutdown the channel if an error occurs.
834    pub fn send_no_shutdown_on_err(
835        self,
836        mut result: Result<&ManagerSuspendContainerResponse, SuspendError>,
837    ) -> Result<(), fidl::Error> {
838        let _result = self.send_raw(result);
839        self.drop_without_shutdown();
840        _result
841    }
842
843    fn send_raw(
844        &self,
845        mut result: Result<&ManagerSuspendContainerResponse, SuspendError>,
846    ) -> Result<(), fidl::Error> {
847        self.control_handle.inner.send::<fidl::encoding::FlexibleResultType<
848            ManagerSuspendContainerResponse,
849            SuspendError,
850        >>(
851            fidl::encoding::FlexibleResult::new(result),
852            self.tx_id,
853            0x928527927c9f2a7,
854            fidl::encoding::DynamicFlags::FLEXIBLE,
855        )
856    }
857}
858
859#[must_use = "FIDL methods require a response to be sent"]
860#[derive(Debug)]
861pub struct ManagerRegisterWakeWatcherResponder {
862    control_handle: std::mem::ManuallyDrop<ManagerControlHandle>,
863    tx_id: u32,
864}
865
866/// Set the the channel to be shutdown (see [`ManagerControlHandle::shutdown`])
867/// if the responder is dropped without sending a response, so that the client
868/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
869impl std::ops::Drop for ManagerRegisterWakeWatcherResponder {
870    fn drop(&mut self) {
871        self.control_handle.shutdown();
872        // Safety: drops once, never accessed again
873        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
874    }
875}
876
877impl fidl::endpoints::Responder for ManagerRegisterWakeWatcherResponder {
878    type ControlHandle = ManagerControlHandle;
879
880    fn control_handle(&self) -> &ManagerControlHandle {
881        &self.control_handle
882    }
883
884    fn drop_without_shutdown(mut self) {
885        // Safety: drops once, never accessed again due to mem::forget
886        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
887        // Prevent Drop from running (which would shut down the channel)
888        std::mem::forget(self);
889    }
890}
891
892impl ManagerRegisterWakeWatcherResponder {
893    /// Sends a response to the FIDL transaction.
894    ///
895    /// Sets the channel to shutdown if an error occurs.
896    pub fn send(self) -> Result<(), fidl::Error> {
897        let _result = self.send_raw();
898        if _result.is_err() {
899            self.control_handle.shutdown();
900        }
901        self.drop_without_shutdown();
902        _result
903    }
904
905    /// Similar to "send" but does not shutdown the channel if an error occurs.
906    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
907        let _result = self.send_raw();
908        self.drop_without_shutdown();
909        _result
910    }
911
912    fn send_raw(&self) -> Result<(), fidl::Error> {
913        self.control_handle.inner.send::<fidl::encoding::FlexibleType<fidl::encoding::EmptyStruct>>(
914            fidl::encoding::Flexible::new(()),
915            self.tx_id,
916            0x456d74519eb65b41,
917            fidl::encoding::DynamicFlags::FLEXIBLE,
918        )
919    }
920}
921
922#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
923pub struct PagerMarker;
924
925impl fidl::endpoints::ProtocolMarker for PagerMarker {
926    type Proxy = PagerProxy;
927    type RequestStream = PagerRequestStream;
928    #[cfg(target_os = "fuchsia")]
929    type SynchronousProxy = PagerSynchronousProxy;
930
931    const DEBUG_NAME: &'static str = "(anonymous) Pager";
932}
933pub type PagerRegisterFileResult = Result<PagerRegisterFileResponse, i32>;
934
935pub trait PagerProxyInterface: Send + Sync {
936    type RegisterFileResponseFut: std::future::Future<Output = Result<PagerRegisterFileResult, fidl::Error>>
937        + Send;
938    fn r#register_file(&self, payload: &PagerRegisterFileRequest) -> Self::RegisterFileResponseFut;
939}
940#[derive(Debug)]
941#[cfg(target_os = "fuchsia")]
942pub struct PagerSynchronousProxy {
943    client: fidl::client::sync::Client,
944}
945
946#[cfg(target_os = "fuchsia")]
947impl fidl::endpoints::SynchronousProxy for PagerSynchronousProxy {
948    type Proxy = PagerProxy;
949    type Protocol = PagerMarker;
950
951    fn from_channel(inner: fidl::Channel) -> Self {
952        Self::new(inner)
953    }
954
955    fn into_channel(self) -> fidl::Channel {
956        self.client.into_channel()
957    }
958
959    fn as_channel(&self) -> &fidl::Channel {
960        self.client.as_channel()
961    }
962}
963
964#[cfg(target_os = "fuchsia")]
965impl PagerSynchronousProxy {
966    pub fn new(channel: fidl::Channel) -> Self {
967        let protocol_name = <PagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
968        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
969    }
970
971    pub fn into_channel(self) -> fidl::Channel {
972        self.client.into_channel()
973    }
974
975    /// Waits until an event arrives and returns it. It is safe for other
976    /// threads to make concurrent requests while waiting for an event.
977    pub fn wait_for_event(
978        &self,
979        deadline: zx::MonotonicInstant,
980    ) -> Result<PagerEvent, fidl::Error> {
981        PagerEvent::decode(self.client.wait_for_event(deadline)?)
982    }
983
984    /// Registers a file with the pager.
985    pub fn r#register_file(
986        &self,
987        mut payload: &PagerRegisterFileRequest,
988        ___deadline: zx::MonotonicInstant,
989    ) -> Result<PagerRegisterFileResult, fidl::Error> {
990        let _response = self.client.send_query::<
991            PagerRegisterFileRequest,
992            fidl::encoding::FlexibleResultType<PagerRegisterFileResponse, i32>,
993        >(
994            payload,
995            0x4f85a2ce6cae4aed,
996            fidl::encoding::DynamicFlags::FLEXIBLE,
997            ___deadline,
998        )?
999        .into_result::<PagerMarker>("register_file")?;
1000        Ok(_response.map(|x| x))
1001    }
1002}
1003
1004#[cfg(target_os = "fuchsia")]
1005impl From<PagerSynchronousProxy> for zx::Handle {
1006    fn from(value: PagerSynchronousProxy) -> Self {
1007        value.into_channel().into()
1008    }
1009}
1010
1011#[cfg(target_os = "fuchsia")]
1012impl From<fidl::Channel> for PagerSynchronousProxy {
1013    fn from(value: fidl::Channel) -> Self {
1014        Self::new(value)
1015    }
1016}
1017
1018#[derive(Debug, Clone)]
1019pub struct PagerProxy {
1020    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1021}
1022
1023impl fidl::endpoints::Proxy for PagerProxy {
1024    type Protocol = PagerMarker;
1025
1026    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1027        Self::new(inner)
1028    }
1029
1030    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1031        self.client.into_channel().map_err(|client| Self { client })
1032    }
1033
1034    fn as_channel(&self) -> &::fidl::AsyncChannel {
1035        self.client.as_channel()
1036    }
1037}
1038
1039impl PagerProxy {
1040    /// Create a new Proxy for fuchsia.starnix.runner/Pager.
1041    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1042        let protocol_name = <PagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1043        Self { client: fidl::client::Client::new(channel, protocol_name) }
1044    }
1045
1046    /// Get a Stream of events from the remote end of the protocol.
1047    ///
1048    /// # Panics
1049    ///
1050    /// Panics if the event stream was already taken.
1051    pub fn take_event_stream(&self) -> PagerEventStream {
1052        PagerEventStream { event_receiver: self.client.take_event_receiver() }
1053    }
1054
1055    /// Registers a file with the pager.
1056    pub fn r#register_file(
1057        &self,
1058        mut payload: &PagerRegisterFileRequest,
1059    ) -> fidl::client::QueryResponseFut<
1060        PagerRegisterFileResult,
1061        fidl::encoding::DefaultFuchsiaResourceDialect,
1062    > {
1063        PagerProxyInterface::r#register_file(self, payload)
1064    }
1065}
1066
1067impl PagerProxyInterface for PagerProxy {
1068    type RegisterFileResponseFut = fidl::client::QueryResponseFut<
1069        PagerRegisterFileResult,
1070        fidl::encoding::DefaultFuchsiaResourceDialect,
1071    >;
1072    fn r#register_file(
1073        &self,
1074        mut payload: &PagerRegisterFileRequest,
1075    ) -> Self::RegisterFileResponseFut {
1076        fn _decode(
1077            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1078        ) -> Result<PagerRegisterFileResult, fidl::Error> {
1079            let _response = fidl::client::decode_transaction_body::<
1080                fidl::encoding::FlexibleResultType<PagerRegisterFileResponse, i32>,
1081                fidl::encoding::DefaultFuchsiaResourceDialect,
1082                0x4f85a2ce6cae4aed,
1083            >(_buf?)?
1084            .into_result::<PagerMarker>("register_file")?;
1085            Ok(_response.map(|x| x))
1086        }
1087        self.client.send_query_and_decode::<PagerRegisterFileRequest, PagerRegisterFileResult>(
1088            payload,
1089            0x4f85a2ce6cae4aed,
1090            fidl::encoding::DynamicFlags::FLEXIBLE,
1091            _decode,
1092        )
1093    }
1094}
1095
1096pub struct PagerEventStream {
1097    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
1098}
1099
1100impl std::marker::Unpin for PagerEventStream {}
1101
1102impl futures::stream::FusedStream for PagerEventStream {
1103    fn is_terminated(&self) -> bool {
1104        self.event_receiver.is_terminated()
1105    }
1106}
1107
1108impl futures::Stream for PagerEventStream {
1109    type Item = Result<PagerEvent, fidl::Error>;
1110
1111    fn poll_next(
1112        mut self: std::pin::Pin<&mut Self>,
1113        cx: &mut std::task::Context<'_>,
1114    ) -> std::task::Poll<Option<Self::Item>> {
1115        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
1116            &mut self.event_receiver,
1117            cx
1118        )?) {
1119            Some(buf) => std::task::Poll::Ready(Some(PagerEvent::decode(buf))),
1120            None => std::task::Poll::Ready(None),
1121        }
1122    }
1123}
1124
1125#[derive(Debug)]
1126pub enum PagerEvent {
1127    #[non_exhaustive]
1128    _UnknownEvent {
1129        /// Ordinal of the event that was sent.
1130        ordinal: u64,
1131    },
1132}
1133
1134impl PagerEvent {
1135    /// Decodes a message buffer as a [`PagerEvent`].
1136    fn decode(
1137        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
1138    ) -> Result<PagerEvent, fidl::Error> {
1139        let (bytes, _handles) = buf.split_mut();
1140        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1141        debug_assert_eq!(tx_header.tx_id, 0);
1142        match tx_header.ordinal {
1143            _ if tx_header.dynamic_flags().contains(fidl::encoding::DynamicFlags::FLEXIBLE) => {
1144                Ok(PagerEvent::_UnknownEvent { ordinal: tx_header.ordinal })
1145            }
1146            _ => Err(fidl::Error::UnknownOrdinal {
1147                ordinal: tx_header.ordinal,
1148                protocol_name: <PagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1149            }),
1150        }
1151    }
1152}
1153
1154/// A Stream of incoming requests for fuchsia.starnix.runner/Pager.
1155pub struct PagerRequestStream {
1156    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1157    is_terminated: bool,
1158}
1159
1160impl std::marker::Unpin for PagerRequestStream {}
1161
1162impl futures::stream::FusedStream for PagerRequestStream {
1163    fn is_terminated(&self) -> bool {
1164        self.is_terminated
1165    }
1166}
1167
1168impl fidl::endpoints::RequestStream for PagerRequestStream {
1169    type Protocol = PagerMarker;
1170    type ControlHandle = PagerControlHandle;
1171
1172    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
1173        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
1174    }
1175
1176    fn control_handle(&self) -> Self::ControlHandle {
1177        PagerControlHandle { inner: self.inner.clone() }
1178    }
1179
1180    fn into_inner(
1181        self,
1182    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
1183    {
1184        (self.inner, self.is_terminated)
1185    }
1186
1187    fn from_inner(
1188        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1189        is_terminated: bool,
1190    ) -> Self {
1191        Self { inner, is_terminated }
1192    }
1193}
1194
1195impl futures::Stream for PagerRequestStream {
1196    type Item = Result<PagerRequest, fidl::Error>;
1197
1198    fn poll_next(
1199        mut self: std::pin::Pin<&mut Self>,
1200        cx: &mut std::task::Context<'_>,
1201    ) -> std::task::Poll<Option<Self::Item>> {
1202        let this = &mut *self;
1203        if this.inner.check_shutdown(cx) {
1204            this.is_terminated = true;
1205            return std::task::Poll::Ready(None);
1206        }
1207        if this.is_terminated {
1208            panic!("polled PagerRequestStream after completion");
1209        }
1210        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
1211            |bytes, handles| {
1212                match this.inner.channel().read_etc(cx, bytes, handles) {
1213                    std::task::Poll::Ready(Ok(())) => {}
1214                    std::task::Poll::Pending => return std::task::Poll::Pending,
1215                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
1216                        this.is_terminated = true;
1217                        return std::task::Poll::Ready(None);
1218                    }
1219                    std::task::Poll::Ready(Err(e)) => {
1220                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
1221                            e.into(),
1222                        ))))
1223                    }
1224                }
1225
1226                // A message has been received from the channel
1227                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1228
1229                std::task::Poll::Ready(Some(match header.ordinal {
1230                    0x4f85a2ce6cae4aed => {
1231                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1232                        let mut req = fidl::new_empty!(
1233                            PagerRegisterFileRequest,
1234                            fidl::encoding::DefaultFuchsiaResourceDialect
1235                        );
1236                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PagerRegisterFileRequest>(&header, _body_bytes, handles, &mut req)?;
1237                        let control_handle = PagerControlHandle { inner: this.inner.clone() };
1238                        Ok(PagerRequest::RegisterFile {
1239                            payload: req,
1240                            responder: PagerRegisterFileResponder {
1241                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1242                                tx_id: header.tx_id,
1243                            },
1244                        })
1245                    }
1246                    _ if header.tx_id == 0
1247                        && header
1248                            .dynamic_flags()
1249                            .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
1250                    {
1251                        Ok(PagerRequest::_UnknownMethod {
1252                            ordinal: header.ordinal,
1253                            control_handle: PagerControlHandle { inner: this.inner.clone() },
1254                            method_type: fidl::MethodType::OneWay,
1255                        })
1256                    }
1257                    _ if header
1258                        .dynamic_flags()
1259                        .contains(fidl::encoding::DynamicFlags::FLEXIBLE) =>
1260                    {
1261                        this.inner.send_framework_err(
1262                            fidl::encoding::FrameworkErr::UnknownMethod,
1263                            header.tx_id,
1264                            header.ordinal,
1265                            header.dynamic_flags(),
1266                            (bytes, handles),
1267                        )?;
1268                        Ok(PagerRequest::_UnknownMethod {
1269                            ordinal: header.ordinal,
1270                            control_handle: PagerControlHandle { inner: this.inner.clone() },
1271                            method_type: fidl::MethodType::TwoWay,
1272                        })
1273                    }
1274                    _ => Err(fidl::Error::UnknownOrdinal {
1275                        ordinal: header.ordinal,
1276                        protocol_name: <PagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1277                    }),
1278                }))
1279            },
1280        )
1281    }
1282}
1283
1284#[derive(Debug)]
1285pub enum PagerRequest {
1286    /// Registers a file with the pager.
1287    RegisterFile { payload: PagerRegisterFileRequest, responder: PagerRegisterFileResponder },
1288    /// An interaction was received which does not match any known method.
1289    #[non_exhaustive]
1290    _UnknownMethod {
1291        /// Ordinal of the method that was called.
1292        ordinal: u64,
1293        control_handle: PagerControlHandle,
1294        method_type: fidl::MethodType,
1295    },
1296}
1297
1298impl PagerRequest {
1299    #[allow(irrefutable_let_patterns)]
1300    pub fn into_register_file(
1301        self,
1302    ) -> Option<(PagerRegisterFileRequest, PagerRegisterFileResponder)> {
1303        if let PagerRequest::RegisterFile { payload, responder } = self {
1304            Some((payload, responder))
1305        } else {
1306            None
1307        }
1308    }
1309
1310    /// Name of the method defined in FIDL
1311    pub fn method_name(&self) -> &'static str {
1312        match *self {
1313            PagerRequest::RegisterFile { .. } => "register_file",
1314            PagerRequest::_UnknownMethod { method_type: fidl::MethodType::OneWay, .. } => {
1315                "unknown one-way method"
1316            }
1317            PagerRequest::_UnknownMethod { method_type: fidl::MethodType::TwoWay, .. } => {
1318                "unknown two-way method"
1319            }
1320        }
1321    }
1322}
1323
1324#[derive(Debug, Clone)]
1325pub struct PagerControlHandle {
1326    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1327}
1328
1329impl fidl::endpoints::ControlHandle for PagerControlHandle {
1330    fn shutdown(&self) {
1331        self.inner.shutdown()
1332    }
1333    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1334        self.inner.shutdown_with_epitaph(status)
1335    }
1336
1337    fn is_closed(&self) -> bool {
1338        self.inner.channel().is_closed()
1339    }
1340    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1341        self.inner.channel().on_closed()
1342    }
1343
1344    #[cfg(target_os = "fuchsia")]
1345    fn signal_peer(
1346        &self,
1347        clear_mask: zx::Signals,
1348        set_mask: zx::Signals,
1349    ) -> Result<(), zx_status::Status> {
1350        use fidl::Peered;
1351        self.inner.channel().signal_peer(clear_mask, set_mask)
1352    }
1353}
1354
1355impl PagerControlHandle {}
1356
1357#[must_use = "FIDL methods require a response to be sent"]
1358#[derive(Debug)]
1359pub struct PagerRegisterFileResponder {
1360    control_handle: std::mem::ManuallyDrop<PagerControlHandle>,
1361    tx_id: u32,
1362}
1363
1364/// Set the the channel to be shutdown (see [`PagerControlHandle::shutdown`])
1365/// if the responder is dropped without sending a response, so that the client
1366/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1367impl std::ops::Drop for PagerRegisterFileResponder {
1368    fn drop(&mut self) {
1369        self.control_handle.shutdown();
1370        // Safety: drops once, never accessed again
1371        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1372    }
1373}
1374
1375impl fidl::endpoints::Responder for PagerRegisterFileResponder {
1376    type ControlHandle = PagerControlHandle;
1377
1378    fn control_handle(&self) -> &PagerControlHandle {
1379        &self.control_handle
1380    }
1381
1382    fn drop_without_shutdown(mut self) {
1383        // Safety: drops once, never accessed again due to mem::forget
1384        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1385        // Prevent Drop from running (which would shut down the channel)
1386        std::mem::forget(self);
1387    }
1388}
1389
1390impl PagerRegisterFileResponder {
1391    /// Sends a response to the FIDL transaction.
1392    ///
1393    /// Sets the channel to shutdown if an error occurs.
1394    pub fn send(
1395        self,
1396        mut result: Result<PagerRegisterFileResponse, i32>,
1397    ) -> Result<(), fidl::Error> {
1398        let _result = self.send_raw(result);
1399        if _result.is_err() {
1400            self.control_handle.shutdown();
1401        }
1402        self.drop_without_shutdown();
1403        _result
1404    }
1405
1406    /// Similar to "send" but does not shutdown the channel if an error occurs.
1407    pub fn send_no_shutdown_on_err(
1408        self,
1409        mut result: Result<PagerRegisterFileResponse, i32>,
1410    ) -> Result<(), fidl::Error> {
1411        let _result = self.send_raw(result);
1412        self.drop_without_shutdown();
1413        _result
1414    }
1415
1416    fn send_raw(
1417        &self,
1418        mut result: Result<PagerRegisterFileResponse, i32>,
1419    ) -> Result<(), fidl::Error> {
1420        self.control_handle
1421            .inner
1422            .send::<fidl::encoding::FlexibleResultType<PagerRegisterFileResponse, i32>>(
1423                fidl::encoding::FlexibleResult::new(result.as_mut().map_err(|e| *e)),
1424                self.tx_id,
1425                0x4f85a2ce6cae4aed,
1426                fidl::encoding::DynamicFlags::FLEXIBLE,
1427            )
1428    }
1429}
1430
1431mod internal {
1432    use super::*;
1433
1434    impl ManagerCreatePagerRequest {
1435        #[inline(always)]
1436        fn max_ordinal_present(&self) -> u64 {
1437            if let Some(_) = self.pager {
1438                return 3;
1439            }
1440            if let Some(_) = self.block_size {
1441                return 2;
1442            }
1443            if let Some(_) = self.backing_vmo {
1444                return 1;
1445            }
1446            0
1447        }
1448    }
1449
1450    impl fidl::encoding::ResourceTypeMarker for ManagerCreatePagerRequest {
1451        type Borrowed<'a> = &'a mut Self;
1452        fn take_or_borrow<'a>(
1453            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1454        ) -> Self::Borrowed<'a> {
1455            value
1456        }
1457    }
1458
1459    unsafe impl fidl::encoding::TypeMarker for ManagerCreatePagerRequest {
1460        type Owned = Self;
1461
1462        #[inline(always)]
1463        fn inline_align(_context: fidl::encoding::Context) -> usize {
1464            8
1465        }
1466
1467        #[inline(always)]
1468        fn inline_size(_context: fidl::encoding::Context) -> usize {
1469            16
1470        }
1471    }
1472
1473    unsafe impl
1474        fidl::encoding::Encode<
1475            ManagerCreatePagerRequest,
1476            fidl::encoding::DefaultFuchsiaResourceDialect,
1477        > for &mut ManagerCreatePagerRequest
1478    {
1479        unsafe fn encode(
1480            self,
1481            encoder: &mut fidl::encoding::Encoder<
1482                '_,
1483                fidl::encoding::DefaultFuchsiaResourceDialect,
1484            >,
1485            offset: usize,
1486            mut depth: fidl::encoding::Depth,
1487        ) -> fidl::Result<()> {
1488            encoder.debug_check_bounds::<ManagerCreatePagerRequest>(offset);
1489            // Vector header
1490            let max_ordinal: u64 = self.max_ordinal_present();
1491            encoder.write_num(max_ordinal, offset);
1492            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1493            // Calling encoder.out_of_line_offset(0) is not allowed.
1494            if max_ordinal == 0 {
1495                return Ok(());
1496            }
1497            depth.increment()?;
1498            let envelope_size = 8;
1499            let bytes_len = max_ordinal as usize * envelope_size;
1500            #[allow(unused_variables)]
1501            let offset = encoder.out_of_line_offset(bytes_len);
1502            let mut _prev_end_offset: usize = 0;
1503            if 1 > max_ordinal {
1504                return Ok(());
1505            }
1506
1507            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1508            // are envelope_size bytes.
1509            let cur_offset: usize = (1 - 1) * envelope_size;
1510
1511            // Zero reserved fields.
1512            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1513
1514            // Safety:
1515            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1516            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1517            //   envelope_size bytes, there is always sufficient room.
1518            fidl::encoding::encode_in_envelope_optional::<
1519                fidl::encoding::HandleType<
1520                    fidl::Vmo,
1521                    { fidl::ObjectType::VMO.into_raw() },
1522                    2147483648,
1523                >,
1524                fidl::encoding::DefaultFuchsiaResourceDialect,
1525            >(
1526                self.backing_vmo.as_mut().map(
1527                    <fidl::encoding::HandleType<
1528                        fidl::Vmo,
1529                        { fidl::ObjectType::VMO.into_raw() },
1530                        2147483648,
1531                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
1532                ),
1533                encoder,
1534                offset + cur_offset,
1535                depth,
1536            )?;
1537
1538            _prev_end_offset = cur_offset + envelope_size;
1539            if 2 > max_ordinal {
1540                return Ok(());
1541            }
1542
1543            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1544            // are envelope_size bytes.
1545            let cur_offset: usize = (2 - 1) * envelope_size;
1546
1547            // Zero reserved fields.
1548            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1549
1550            // Safety:
1551            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1552            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1553            //   envelope_size bytes, there is always sufficient room.
1554            fidl::encoding::encode_in_envelope_optional::<
1555                u64,
1556                fidl::encoding::DefaultFuchsiaResourceDialect,
1557            >(
1558                self.block_size.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
1559                encoder,
1560                offset + cur_offset,
1561                depth,
1562            )?;
1563
1564            _prev_end_offset = cur_offset + envelope_size;
1565            if 3 > max_ordinal {
1566                return Ok(());
1567            }
1568
1569            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1570            // are envelope_size bytes.
1571            let cur_offset: usize = (3 - 1) * envelope_size;
1572
1573            // Zero reserved fields.
1574            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1575
1576            // Safety:
1577            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1578            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1579            //   envelope_size bytes, there is always sufficient room.
1580            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PagerMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
1581            self.pager.as_mut().map(<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PagerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
1582            encoder, offset + cur_offset, depth
1583        )?;
1584
1585            _prev_end_offset = cur_offset + envelope_size;
1586
1587            Ok(())
1588        }
1589    }
1590
1591    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
1592        for ManagerCreatePagerRequest
1593    {
1594        #[inline(always)]
1595        fn new_empty() -> Self {
1596            Self::default()
1597        }
1598
1599        unsafe fn decode(
1600            &mut self,
1601            decoder: &mut fidl::encoding::Decoder<
1602                '_,
1603                fidl::encoding::DefaultFuchsiaResourceDialect,
1604            >,
1605            offset: usize,
1606            mut depth: fidl::encoding::Depth,
1607        ) -> fidl::Result<()> {
1608            decoder.debug_check_bounds::<Self>(offset);
1609            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
1610                None => return Err(fidl::Error::NotNullable),
1611                Some(len) => len,
1612            };
1613            // Calling decoder.out_of_line_offset(0) is not allowed.
1614            if len == 0 {
1615                return Ok(());
1616            };
1617            depth.increment()?;
1618            let envelope_size = 8;
1619            let bytes_len = len * envelope_size;
1620            let offset = decoder.out_of_line_offset(bytes_len)?;
1621            // Decode the envelope for each type.
1622            let mut _next_ordinal_to_read = 0;
1623            let mut next_offset = offset;
1624            let end_offset = offset + bytes_len;
1625            _next_ordinal_to_read += 1;
1626            if next_offset >= end_offset {
1627                return Ok(());
1628            }
1629
1630            // Decode unknown envelopes for gaps in ordinals.
1631            while _next_ordinal_to_read < 1 {
1632                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1633                _next_ordinal_to_read += 1;
1634                next_offset += envelope_size;
1635            }
1636
1637            let next_out_of_line = decoder.next_out_of_line();
1638            let handles_before = decoder.remaining_handles();
1639            if let Some((inlined, num_bytes, num_handles)) =
1640                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1641            {
1642                let member_inline_size = <fidl::encoding::HandleType<
1643                    fidl::Vmo,
1644                    { fidl::ObjectType::VMO.into_raw() },
1645                    2147483648,
1646                > as fidl::encoding::TypeMarker>::inline_size(
1647                    decoder.context
1648                );
1649                if inlined != (member_inline_size <= 4) {
1650                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1651                }
1652                let inner_offset;
1653                let mut inner_depth = depth.clone();
1654                if inlined {
1655                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1656                    inner_offset = next_offset;
1657                } else {
1658                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1659                    inner_depth.increment()?;
1660                }
1661                let val_ref =
1662                self.backing_vmo.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
1663                fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
1664                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1665                {
1666                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1667                }
1668                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1669                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1670                }
1671            }
1672
1673            next_offset += envelope_size;
1674            _next_ordinal_to_read += 1;
1675            if next_offset >= end_offset {
1676                return Ok(());
1677            }
1678
1679            // Decode unknown envelopes for gaps in ordinals.
1680            while _next_ordinal_to_read < 2 {
1681                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1682                _next_ordinal_to_read += 1;
1683                next_offset += envelope_size;
1684            }
1685
1686            let next_out_of_line = decoder.next_out_of_line();
1687            let handles_before = decoder.remaining_handles();
1688            if let Some((inlined, num_bytes, num_handles)) =
1689                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1690            {
1691                let member_inline_size =
1692                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
1693                if inlined != (member_inline_size <= 4) {
1694                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1695                }
1696                let inner_offset;
1697                let mut inner_depth = depth.clone();
1698                if inlined {
1699                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1700                    inner_offset = next_offset;
1701                } else {
1702                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1703                    inner_depth.increment()?;
1704                }
1705                let val_ref = self.block_size.get_or_insert_with(|| {
1706                    fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect)
1707                });
1708                fidl::decode!(
1709                    u64,
1710                    fidl::encoding::DefaultFuchsiaResourceDialect,
1711                    val_ref,
1712                    decoder,
1713                    inner_offset,
1714                    inner_depth
1715                )?;
1716                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1717                {
1718                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1719                }
1720                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1721                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1722                }
1723            }
1724
1725            next_offset += envelope_size;
1726            _next_ordinal_to_read += 1;
1727            if next_offset >= end_offset {
1728                return Ok(());
1729            }
1730
1731            // Decode unknown envelopes for gaps in ordinals.
1732            while _next_ordinal_to_read < 3 {
1733                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1734                _next_ordinal_to_read += 1;
1735                next_offset += envelope_size;
1736            }
1737
1738            let next_out_of_line = decoder.next_out_of_line();
1739            let handles_before = decoder.remaining_handles();
1740            if let Some((inlined, num_bytes, num_handles)) =
1741                fidl::encoding::decode_envelope_header(decoder, next_offset)?
1742            {
1743                let member_inline_size = <fidl::encoding::Endpoint<
1744                    fidl::endpoints::ServerEnd<PagerMarker>,
1745                > as fidl::encoding::TypeMarker>::inline_size(
1746                    decoder.context
1747                );
1748                if inlined != (member_inline_size <= 4) {
1749                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
1750                }
1751                let inner_offset;
1752                let mut inner_depth = depth.clone();
1753                if inlined {
1754                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
1755                    inner_offset = next_offset;
1756                } else {
1757                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
1758                    inner_depth.increment()?;
1759                }
1760                let val_ref = self.pager.get_or_insert_with(|| {
1761                    fidl::new_empty!(
1762                        fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PagerMarker>>,
1763                        fidl::encoding::DefaultFuchsiaResourceDialect
1764                    )
1765                });
1766                fidl::decode!(
1767                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PagerMarker>>,
1768                    fidl::encoding::DefaultFuchsiaResourceDialect,
1769                    val_ref,
1770                    decoder,
1771                    inner_offset,
1772                    inner_depth
1773                )?;
1774                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
1775                {
1776                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
1777                }
1778                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
1779                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
1780                }
1781            }
1782
1783            next_offset += envelope_size;
1784
1785            // Decode the remaining unknown envelopes.
1786            while next_offset < end_offset {
1787                _next_ordinal_to_read += 1;
1788                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
1789                next_offset += envelope_size;
1790            }
1791
1792            Ok(())
1793        }
1794    }
1795
1796    impl ManagerProxyWakeChannelRequest {
1797        #[inline(always)]
1798        fn max_ordinal_present(&self) -> u64 {
1799            if let Some(_) = self.counter {
1800                return 5;
1801            }
1802            if let Some(_) = self.name {
1803                return 4;
1804            }
1805            if let Some(_) = self.remote_channel {
1806                return 3;
1807            }
1808            if let Some(_) = self.container_channel {
1809                return 2;
1810            }
1811            if let Some(_) = self.container_job {
1812                return 1;
1813            }
1814            0
1815        }
1816    }
1817
1818    impl fidl::encoding::ResourceTypeMarker for ManagerProxyWakeChannelRequest {
1819        type Borrowed<'a> = &'a mut Self;
1820        fn take_or_borrow<'a>(
1821            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
1822        ) -> Self::Borrowed<'a> {
1823            value
1824        }
1825    }
1826
1827    unsafe impl fidl::encoding::TypeMarker for ManagerProxyWakeChannelRequest {
1828        type Owned = Self;
1829
1830        #[inline(always)]
1831        fn inline_align(_context: fidl::encoding::Context) -> usize {
1832            8
1833        }
1834
1835        #[inline(always)]
1836        fn inline_size(_context: fidl::encoding::Context) -> usize {
1837            16
1838        }
1839    }
1840
1841    unsafe impl
1842        fidl::encoding::Encode<
1843            ManagerProxyWakeChannelRequest,
1844            fidl::encoding::DefaultFuchsiaResourceDialect,
1845        > for &mut ManagerProxyWakeChannelRequest
1846    {
1847        unsafe fn encode(
1848            self,
1849            encoder: &mut fidl::encoding::Encoder<
1850                '_,
1851                fidl::encoding::DefaultFuchsiaResourceDialect,
1852            >,
1853            offset: usize,
1854            mut depth: fidl::encoding::Depth,
1855        ) -> fidl::Result<()> {
1856            encoder.debug_check_bounds::<ManagerProxyWakeChannelRequest>(offset);
1857            // Vector header
1858            let max_ordinal: u64 = self.max_ordinal_present();
1859            encoder.write_num(max_ordinal, offset);
1860            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1861            // Calling encoder.out_of_line_offset(0) is not allowed.
1862            if max_ordinal == 0 {
1863                return Ok(());
1864            }
1865            depth.increment()?;
1866            let envelope_size = 8;
1867            let bytes_len = max_ordinal as usize * envelope_size;
1868            #[allow(unused_variables)]
1869            let offset = encoder.out_of_line_offset(bytes_len);
1870            let mut _prev_end_offset: usize = 0;
1871            if 1 > max_ordinal {
1872                return Ok(());
1873            }
1874
1875            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1876            // are envelope_size bytes.
1877            let cur_offset: usize = (1 - 1) * envelope_size;
1878
1879            // Zero reserved fields.
1880            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1881
1882            // Safety:
1883            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1884            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1885            //   envelope_size bytes, there is always sufficient room.
1886            fidl::encoding::encode_in_envelope_optional::<
1887                fidl::encoding::HandleType<
1888                    fidl::Job,
1889                    { fidl::ObjectType::JOB.into_raw() },
1890                    2147483648,
1891                >,
1892                fidl::encoding::DefaultFuchsiaResourceDialect,
1893            >(
1894                self.container_job.as_mut().map(
1895                    <fidl::encoding::HandleType<
1896                        fidl::Job,
1897                        { fidl::ObjectType::JOB.into_raw() },
1898                        2147483648,
1899                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
1900                ),
1901                encoder,
1902                offset + cur_offset,
1903                depth,
1904            )?;
1905
1906            _prev_end_offset = cur_offset + envelope_size;
1907            if 2 > max_ordinal {
1908                return Ok(());
1909            }
1910
1911            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1912            // are envelope_size bytes.
1913            let cur_offset: usize = (2 - 1) * envelope_size;
1914
1915            // Zero reserved fields.
1916            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1917
1918            // Safety:
1919            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1920            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1921            //   envelope_size bytes, there is always sufficient room.
1922            fidl::encoding::encode_in_envelope_optional::<
1923                fidl::encoding::HandleType<
1924                    fidl::Channel,
1925                    { fidl::ObjectType::CHANNEL.into_raw() },
1926                    2147483648,
1927                >,
1928                fidl::encoding::DefaultFuchsiaResourceDialect,
1929            >(
1930                self.container_channel.as_mut().map(
1931                    <fidl::encoding::HandleType<
1932                        fidl::Channel,
1933                        { fidl::ObjectType::CHANNEL.into_raw() },
1934                        2147483648,
1935                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
1936                ),
1937                encoder,
1938                offset + cur_offset,
1939                depth,
1940            )?;
1941
1942            _prev_end_offset = cur_offset + envelope_size;
1943            if 3 > max_ordinal {
1944                return Ok(());
1945            }
1946
1947            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1948            // are envelope_size bytes.
1949            let cur_offset: usize = (3 - 1) * envelope_size;
1950
1951            // Zero reserved fields.
1952            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1953
1954            // Safety:
1955            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1956            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1957            //   envelope_size bytes, there is always sufficient room.
1958            fidl::encoding::encode_in_envelope_optional::<
1959                fidl::encoding::HandleType<
1960                    fidl::Channel,
1961                    { fidl::ObjectType::CHANNEL.into_raw() },
1962                    2147483648,
1963                >,
1964                fidl::encoding::DefaultFuchsiaResourceDialect,
1965            >(
1966                self.remote_channel.as_mut().map(
1967                    <fidl::encoding::HandleType<
1968                        fidl::Channel,
1969                        { fidl::ObjectType::CHANNEL.into_raw() },
1970                        2147483648,
1971                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
1972                ),
1973                encoder,
1974                offset + cur_offset,
1975                depth,
1976            )?;
1977
1978            _prev_end_offset = cur_offset + envelope_size;
1979            if 4 > max_ordinal {
1980                return Ok(());
1981            }
1982
1983            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1984            // are envelope_size bytes.
1985            let cur_offset: usize = (4 - 1) * envelope_size;
1986
1987            // Zero reserved fields.
1988            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1989
1990            // Safety:
1991            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1992            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1993            //   envelope_size bytes, there is always sufficient room.
1994            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<1024>, fidl::encoding::DefaultFuchsiaResourceDialect>(
1995            self.name.as_ref().map(<fidl::encoding::BoundedString<1024> as fidl::encoding::ValueTypeMarker>::borrow),
1996            encoder, offset + cur_offset, depth
1997        )?;
1998
1999            _prev_end_offset = cur_offset + envelope_size;
2000            if 5 > max_ordinal {
2001                return Ok(());
2002            }
2003
2004            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2005            // are envelope_size bytes.
2006            let cur_offset: usize = (5 - 1) * envelope_size;
2007
2008            // Zero reserved fields.
2009            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2010
2011            // Safety:
2012            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2013            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2014            //   envelope_size bytes, there is always sufficient room.
2015            fidl::encoding::encode_in_envelope_optional::<
2016                fidl::encoding::HandleType<
2017                    fidl::Counter,
2018                    { fidl::ObjectType::COUNTER.into_raw() },
2019                    2147483648,
2020                >,
2021                fidl::encoding::DefaultFuchsiaResourceDialect,
2022            >(
2023                self.counter.as_mut().map(
2024                    <fidl::encoding::HandleType<
2025                        fidl::Counter,
2026                        { fidl::ObjectType::COUNTER.into_raw() },
2027                        2147483648,
2028                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
2029                ),
2030                encoder,
2031                offset + cur_offset,
2032                depth,
2033            )?;
2034
2035            _prev_end_offset = cur_offset + envelope_size;
2036
2037            Ok(())
2038        }
2039    }
2040
2041    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
2042        for ManagerProxyWakeChannelRequest
2043    {
2044        #[inline(always)]
2045        fn new_empty() -> Self {
2046            Self::default()
2047        }
2048
2049        unsafe fn decode(
2050            &mut self,
2051            decoder: &mut fidl::encoding::Decoder<
2052                '_,
2053                fidl::encoding::DefaultFuchsiaResourceDialect,
2054            >,
2055            offset: usize,
2056            mut depth: fidl::encoding::Depth,
2057        ) -> fidl::Result<()> {
2058            decoder.debug_check_bounds::<Self>(offset);
2059            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2060                None => return Err(fidl::Error::NotNullable),
2061                Some(len) => len,
2062            };
2063            // Calling decoder.out_of_line_offset(0) is not allowed.
2064            if len == 0 {
2065                return Ok(());
2066            };
2067            depth.increment()?;
2068            let envelope_size = 8;
2069            let bytes_len = len * envelope_size;
2070            let offset = decoder.out_of_line_offset(bytes_len)?;
2071            // Decode the envelope for each type.
2072            let mut _next_ordinal_to_read = 0;
2073            let mut next_offset = offset;
2074            let end_offset = offset + bytes_len;
2075            _next_ordinal_to_read += 1;
2076            if next_offset >= end_offset {
2077                return Ok(());
2078            }
2079
2080            // Decode unknown envelopes for gaps in ordinals.
2081            while _next_ordinal_to_read < 1 {
2082                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2083                _next_ordinal_to_read += 1;
2084                next_offset += envelope_size;
2085            }
2086
2087            let next_out_of_line = decoder.next_out_of_line();
2088            let handles_before = decoder.remaining_handles();
2089            if let Some((inlined, num_bytes, num_handles)) =
2090                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2091            {
2092                let member_inline_size = <fidl::encoding::HandleType<
2093                    fidl::Job,
2094                    { fidl::ObjectType::JOB.into_raw() },
2095                    2147483648,
2096                > as fidl::encoding::TypeMarker>::inline_size(
2097                    decoder.context
2098                );
2099                if inlined != (member_inline_size <= 4) {
2100                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2101                }
2102                let inner_offset;
2103                let mut inner_depth = depth.clone();
2104                if inlined {
2105                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2106                    inner_offset = next_offset;
2107                } else {
2108                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2109                    inner_depth.increment()?;
2110                }
2111                let val_ref =
2112                self.container_job.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
2113                fidl::decode!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
2114                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2115                {
2116                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2117                }
2118                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2119                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2120                }
2121            }
2122
2123            next_offset += envelope_size;
2124            _next_ordinal_to_read += 1;
2125            if next_offset >= end_offset {
2126                return Ok(());
2127            }
2128
2129            // Decode unknown envelopes for gaps in ordinals.
2130            while _next_ordinal_to_read < 2 {
2131                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2132                _next_ordinal_to_read += 1;
2133                next_offset += envelope_size;
2134            }
2135
2136            let next_out_of_line = decoder.next_out_of_line();
2137            let handles_before = decoder.remaining_handles();
2138            if let Some((inlined, num_bytes, num_handles)) =
2139                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2140            {
2141                let member_inline_size = <fidl::encoding::HandleType<
2142                    fidl::Channel,
2143                    { fidl::ObjectType::CHANNEL.into_raw() },
2144                    2147483648,
2145                > as fidl::encoding::TypeMarker>::inline_size(
2146                    decoder.context
2147                );
2148                if inlined != (member_inline_size <= 4) {
2149                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2150                }
2151                let inner_offset;
2152                let mut inner_depth = depth.clone();
2153                if inlined {
2154                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2155                    inner_offset = next_offset;
2156                } else {
2157                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2158                    inner_depth.increment()?;
2159                }
2160                let val_ref =
2161                self.container_channel.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
2162                fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
2163                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2164                {
2165                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2166                }
2167                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2168                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2169                }
2170            }
2171
2172            next_offset += envelope_size;
2173            _next_ordinal_to_read += 1;
2174            if next_offset >= end_offset {
2175                return Ok(());
2176            }
2177
2178            // Decode unknown envelopes for gaps in ordinals.
2179            while _next_ordinal_to_read < 3 {
2180                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2181                _next_ordinal_to_read += 1;
2182                next_offset += envelope_size;
2183            }
2184
2185            let next_out_of_line = decoder.next_out_of_line();
2186            let handles_before = decoder.remaining_handles();
2187            if let Some((inlined, num_bytes, num_handles)) =
2188                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2189            {
2190                let member_inline_size = <fidl::encoding::HandleType<
2191                    fidl::Channel,
2192                    { fidl::ObjectType::CHANNEL.into_raw() },
2193                    2147483648,
2194                > as fidl::encoding::TypeMarker>::inline_size(
2195                    decoder.context
2196                );
2197                if inlined != (member_inline_size <= 4) {
2198                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2199                }
2200                let inner_offset;
2201                let mut inner_depth = depth.clone();
2202                if inlined {
2203                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2204                    inner_offset = next_offset;
2205                } else {
2206                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2207                    inner_depth.increment()?;
2208                }
2209                let val_ref =
2210                self.remote_channel.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
2211                fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
2212                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2213                {
2214                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2215                }
2216                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2217                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2218                }
2219            }
2220
2221            next_offset += envelope_size;
2222            _next_ordinal_to_read += 1;
2223            if next_offset >= end_offset {
2224                return Ok(());
2225            }
2226
2227            // Decode unknown envelopes for gaps in ordinals.
2228            while _next_ordinal_to_read < 4 {
2229                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2230                _next_ordinal_to_read += 1;
2231                next_offset += envelope_size;
2232            }
2233
2234            let next_out_of_line = decoder.next_out_of_line();
2235            let handles_before = decoder.remaining_handles();
2236            if let Some((inlined, num_bytes, num_handles)) =
2237                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2238            {
2239                let member_inline_size = <fidl::encoding::BoundedString<1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2240                if inlined != (member_inline_size <= 4) {
2241                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2242                }
2243                let inner_offset;
2244                let mut inner_depth = depth.clone();
2245                if inlined {
2246                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2247                    inner_offset = next_offset;
2248                } else {
2249                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2250                    inner_depth.increment()?;
2251                }
2252                let val_ref = self.name.get_or_insert_with(|| {
2253                    fidl::new_empty!(
2254                        fidl::encoding::BoundedString<1024>,
2255                        fidl::encoding::DefaultFuchsiaResourceDialect
2256                    )
2257                });
2258                fidl::decode!(
2259                    fidl::encoding::BoundedString<1024>,
2260                    fidl::encoding::DefaultFuchsiaResourceDialect,
2261                    val_ref,
2262                    decoder,
2263                    inner_offset,
2264                    inner_depth
2265                )?;
2266                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2267                {
2268                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2269                }
2270                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2271                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2272                }
2273            }
2274
2275            next_offset += envelope_size;
2276            _next_ordinal_to_read += 1;
2277            if next_offset >= end_offset {
2278                return Ok(());
2279            }
2280
2281            // Decode unknown envelopes for gaps in ordinals.
2282            while _next_ordinal_to_read < 5 {
2283                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2284                _next_ordinal_to_read += 1;
2285                next_offset += envelope_size;
2286            }
2287
2288            let next_out_of_line = decoder.next_out_of_line();
2289            let handles_before = decoder.remaining_handles();
2290            if let Some((inlined, num_bytes, num_handles)) =
2291                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2292            {
2293                let member_inline_size = <fidl::encoding::HandleType<
2294                    fidl::Counter,
2295                    { fidl::ObjectType::COUNTER.into_raw() },
2296                    2147483648,
2297                > as fidl::encoding::TypeMarker>::inline_size(
2298                    decoder.context
2299                );
2300                if inlined != (member_inline_size <= 4) {
2301                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2302                }
2303                let inner_offset;
2304                let mut inner_depth = depth.clone();
2305                if inlined {
2306                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2307                    inner_offset = next_offset;
2308                } else {
2309                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2310                    inner_depth.increment()?;
2311                }
2312                let val_ref =
2313                self.counter.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Counter, { fidl::ObjectType::COUNTER.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
2314                fidl::decode!(fidl::encoding::HandleType<fidl::Counter, { fidl::ObjectType::COUNTER.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
2315                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2316                {
2317                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2318                }
2319                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2320                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2321                }
2322            }
2323
2324            next_offset += envelope_size;
2325
2326            // Decode the remaining unknown envelopes.
2327            while next_offset < end_offset {
2328                _next_ordinal_to_read += 1;
2329                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2330                next_offset += envelope_size;
2331            }
2332
2333            Ok(())
2334        }
2335    }
2336
2337    impl ManagerRegisterWakeWatcherRequest {
2338        #[inline(always)]
2339        fn max_ordinal_present(&self) -> u64 {
2340            if let Some(_) = self.watcher {
2341                return 1;
2342            }
2343            0
2344        }
2345    }
2346
2347    impl fidl::encoding::ResourceTypeMarker for ManagerRegisterWakeWatcherRequest {
2348        type Borrowed<'a> = &'a mut Self;
2349        fn take_or_borrow<'a>(
2350            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
2351        ) -> Self::Borrowed<'a> {
2352            value
2353        }
2354    }
2355
2356    unsafe impl fidl::encoding::TypeMarker for ManagerRegisterWakeWatcherRequest {
2357        type Owned = Self;
2358
2359        #[inline(always)]
2360        fn inline_align(_context: fidl::encoding::Context) -> usize {
2361            8
2362        }
2363
2364        #[inline(always)]
2365        fn inline_size(_context: fidl::encoding::Context) -> usize {
2366            16
2367        }
2368    }
2369
2370    unsafe impl
2371        fidl::encoding::Encode<
2372            ManagerRegisterWakeWatcherRequest,
2373            fidl::encoding::DefaultFuchsiaResourceDialect,
2374        > for &mut ManagerRegisterWakeWatcherRequest
2375    {
2376        unsafe fn encode(
2377            self,
2378            encoder: &mut fidl::encoding::Encoder<
2379                '_,
2380                fidl::encoding::DefaultFuchsiaResourceDialect,
2381            >,
2382            offset: usize,
2383            mut depth: fidl::encoding::Depth,
2384        ) -> fidl::Result<()> {
2385            encoder.debug_check_bounds::<ManagerRegisterWakeWatcherRequest>(offset);
2386            // Vector header
2387            let max_ordinal: u64 = self.max_ordinal_present();
2388            encoder.write_num(max_ordinal, offset);
2389            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2390            // Calling encoder.out_of_line_offset(0) is not allowed.
2391            if max_ordinal == 0 {
2392                return Ok(());
2393            }
2394            depth.increment()?;
2395            let envelope_size = 8;
2396            let bytes_len = max_ordinal as usize * envelope_size;
2397            #[allow(unused_variables)]
2398            let offset = encoder.out_of_line_offset(bytes_len);
2399            let mut _prev_end_offset: usize = 0;
2400            if 1 > max_ordinal {
2401                return Ok(());
2402            }
2403
2404            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2405            // are envelope_size bytes.
2406            let cur_offset: usize = (1 - 1) * envelope_size;
2407
2408            // Zero reserved fields.
2409            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2410
2411            // Safety:
2412            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2413            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2414            //   envelope_size bytes, there is always sufficient room.
2415            fidl::encoding::encode_in_envelope_optional::<
2416                fidl::encoding::HandleType<
2417                    fidl::EventPair,
2418                    { fidl::ObjectType::EVENTPAIR.into_raw() },
2419                    2147483648,
2420                >,
2421                fidl::encoding::DefaultFuchsiaResourceDialect,
2422            >(
2423                self.watcher.as_mut().map(
2424                    <fidl::encoding::HandleType<
2425                        fidl::EventPair,
2426                        { fidl::ObjectType::EVENTPAIR.into_raw() },
2427                        2147483648,
2428                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
2429                ),
2430                encoder,
2431                offset + cur_offset,
2432                depth,
2433            )?;
2434
2435            _prev_end_offset = cur_offset + envelope_size;
2436
2437            Ok(())
2438        }
2439    }
2440
2441    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
2442        for ManagerRegisterWakeWatcherRequest
2443    {
2444        #[inline(always)]
2445        fn new_empty() -> Self {
2446            Self::default()
2447        }
2448
2449        unsafe fn decode(
2450            &mut self,
2451            decoder: &mut fidl::encoding::Decoder<
2452                '_,
2453                fidl::encoding::DefaultFuchsiaResourceDialect,
2454            >,
2455            offset: usize,
2456            mut depth: fidl::encoding::Depth,
2457        ) -> fidl::Result<()> {
2458            decoder.debug_check_bounds::<Self>(offset);
2459            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2460                None => return Err(fidl::Error::NotNullable),
2461                Some(len) => len,
2462            };
2463            // Calling decoder.out_of_line_offset(0) is not allowed.
2464            if len == 0 {
2465                return Ok(());
2466            };
2467            depth.increment()?;
2468            let envelope_size = 8;
2469            let bytes_len = len * envelope_size;
2470            let offset = decoder.out_of_line_offset(bytes_len)?;
2471            // Decode the envelope for each type.
2472            let mut _next_ordinal_to_read = 0;
2473            let mut next_offset = offset;
2474            let end_offset = offset + bytes_len;
2475            _next_ordinal_to_read += 1;
2476            if next_offset >= end_offset {
2477                return Ok(());
2478            }
2479
2480            // Decode unknown envelopes for gaps in ordinals.
2481            while _next_ordinal_to_read < 1 {
2482                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2483                _next_ordinal_to_read += 1;
2484                next_offset += envelope_size;
2485            }
2486
2487            let next_out_of_line = decoder.next_out_of_line();
2488            let handles_before = decoder.remaining_handles();
2489            if let Some((inlined, num_bytes, num_handles)) =
2490                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2491            {
2492                let member_inline_size = <fidl::encoding::HandleType<
2493                    fidl::EventPair,
2494                    { fidl::ObjectType::EVENTPAIR.into_raw() },
2495                    2147483648,
2496                > as fidl::encoding::TypeMarker>::inline_size(
2497                    decoder.context
2498                );
2499                if inlined != (member_inline_size <= 4) {
2500                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2501                }
2502                let inner_offset;
2503                let mut inner_depth = depth.clone();
2504                if inlined {
2505                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2506                    inner_offset = next_offset;
2507                } else {
2508                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2509                    inner_depth.increment()?;
2510                }
2511                let val_ref =
2512                self.watcher.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
2513                fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
2514                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2515                {
2516                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2517                }
2518                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2519                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2520                }
2521            }
2522
2523            next_offset += envelope_size;
2524
2525            // Decode the remaining unknown envelopes.
2526            while next_offset < end_offset {
2527                _next_ordinal_to_read += 1;
2528                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2529                next_offset += envelope_size;
2530            }
2531
2532            Ok(())
2533        }
2534    }
2535
2536    impl ManagerSuspendContainerRequest {
2537        #[inline(always)]
2538        fn max_ordinal_present(&self) -> u64 {
2539            if let Some(_) = self.wake_locks {
2540                return 2;
2541            }
2542            if let Some(_) = self.container_job {
2543                return 1;
2544            }
2545            0
2546        }
2547    }
2548
2549    impl fidl::encoding::ResourceTypeMarker for ManagerSuspendContainerRequest {
2550        type Borrowed<'a> = &'a mut Self;
2551        fn take_or_borrow<'a>(
2552            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
2553        ) -> Self::Borrowed<'a> {
2554            value
2555        }
2556    }
2557
2558    unsafe impl fidl::encoding::TypeMarker for ManagerSuspendContainerRequest {
2559        type Owned = Self;
2560
2561        #[inline(always)]
2562        fn inline_align(_context: fidl::encoding::Context) -> usize {
2563            8
2564        }
2565
2566        #[inline(always)]
2567        fn inline_size(_context: fidl::encoding::Context) -> usize {
2568            16
2569        }
2570    }
2571
2572    unsafe impl
2573        fidl::encoding::Encode<
2574            ManagerSuspendContainerRequest,
2575            fidl::encoding::DefaultFuchsiaResourceDialect,
2576        > for &mut ManagerSuspendContainerRequest
2577    {
2578        unsafe fn encode(
2579            self,
2580            encoder: &mut fidl::encoding::Encoder<
2581                '_,
2582                fidl::encoding::DefaultFuchsiaResourceDialect,
2583            >,
2584            offset: usize,
2585            mut depth: fidl::encoding::Depth,
2586        ) -> fidl::Result<()> {
2587            encoder.debug_check_bounds::<ManagerSuspendContainerRequest>(offset);
2588            // Vector header
2589            let max_ordinal: u64 = self.max_ordinal_present();
2590            encoder.write_num(max_ordinal, offset);
2591            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2592            // Calling encoder.out_of_line_offset(0) is not allowed.
2593            if max_ordinal == 0 {
2594                return Ok(());
2595            }
2596            depth.increment()?;
2597            let envelope_size = 8;
2598            let bytes_len = max_ordinal as usize * envelope_size;
2599            #[allow(unused_variables)]
2600            let offset = encoder.out_of_line_offset(bytes_len);
2601            let mut _prev_end_offset: usize = 0;
2602            if 1 > max_ordinal {
2603                return Ok(());
2604            }
2605
2606            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2607            // are envelope_size bytes.
2608            let cur_offset: usize = (1 - 1) * envelope_size;
2609
2610            // Zero reserved fields.
2611            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2612
2613            // Safety:
2614            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2615            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2616            //   envelope_size bytes, there is always sufficient room.
2617            fidl::encoding::encode_in_envelope_optional::<
2618                fidl::encoding::HandleType<
2619                    fidl::Job,
2620                    { fidl::ObjectType::JOB.into_raw() },
2621                    2147483648,
2622                >,
2623                fidl::encoding::DefaultFuchsiaResourceDialect,
2624            >(
2625                self.container_job.as_mut().map(
2626                    <fidl::encoding::HandleType<
2627                        fidl::Job,
2628                        { fidl::ObjectType::JOB.into_raw() },
2629                        2147483648,
2630                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
2631                ),
2632                encoder,
2633                offset + cur_offset,
2634                depth,
2635            )?;
2636
2637            _prev_end_offset = cur_offset + envelope_size;
2638            if 2 > max_ordinal {
2639                return Ok(());
2640            }
2641
2642            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2643            // are envelope_size bytes.
2644            let cur_offset: usize = (2 - 1) * envelope_size;
2645
2646            // Zero reserved fields.
2647            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2648
2649            // Safety:
2650            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2651            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2652            //   envelope_size bytes, there is always sufficient room.
2653            fidl::encoding::encode_in_envelope_optional::<
2654                fidl::encoding::HandleType<
2655                    fidl::EventPair,
2656                    { fidl::ObjectType::EVENTPAIR.into_raw() },
2657                    2147483648,
2658                >,
2659                fidl::encoding::DefaultFuchsiaResourceDialect,
2660            >(
2661                self.wake_locks.as_mut().map(
2662                    <fidl::encoding::HandleType<
2663                        fidl::EventPair,
2664                        { fidl::ObjectType::EVENTPAIR.into_raw() },
2665                        2147483648,
2666                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
2667                ),
2668                encoder,
2669                offset + cur_offset,
2670                depth,
2671            )?;
2672
2673            _prev_end_offset = cur_offset + envelope_size;
2674
2675            Ok(())
2676        }
2677    }
2678
2679    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
2680        for ManagerSuspendContainerRequest
2681    {
2682        #[inline(always)]
2683        fn new_empty() -> Self {
2684            Self::default()
2685        }
2686
2687        unsafe fn decode(
2688            &mut self,
2689            decoder: &mut fidl::encoding::Decoder<
2690                '_,
2691                fidl::encoding::DefaultFuchsiaResourceDialect,
2692            >,
2693            offset: usize,
2694            mut depth: fidl::encoding::Depth,
2695        ) -> fidl::Result<()> {
2696            decoder.debug_check_bounds::<Self>(offset);
2697            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2698                None => return Err(fidl::Error::NotNullable),
2699                Some(len) => len,
2700            };
2701            // Calling decoder.out_of_line_offset(0) is not allowed.
2702            if len == 0 {
2703                return Ok(());
2704            };
2705            depth.increment()?;
2706            let envelope_size = 8;
2707            let bytes_len = len * envelope_size;
2708            let offset = decoder.out_of_line_offset(bytes_len)?;
2709            // Decode the envelope for each type.
2710            let mut _next_ordinal_to_read = 0;
2711            let mut next_offset = offset;
2712            let end_offset = offset + bytes_len;
2713            _next_ordinal_to_read += 1;
2714            if next_offset >= end_offset {
2715                return Ok(());
2716            }
2717
2718            // Decode unknown envelopes for gaps in ordinals.
2719            while _next_ordinal_to_read < 1 {
2720                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2721                _next_ordinal_to_read += 1;
2722                next_offset += envelope_size;
2723            }
2724
2725            let next_out_of_line = decoder.next_out_of_line();
2726            let handles_before = decoder.remaining_handles();
2727            if let Some((inlined, num_bytes, num_handles)) =
2728                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2729            {
2730                let member_inline_size = <fidl::encoding::HandleType<
2731                    fidl::Job,
2732                    { fidl::ObjectType::JOB.into_raw() },
2733                    2147483648,
2734                > as fidl::encoding::TypeMarker>::inline_size(
2735                    decoder.context
2736                );
2737                if inlined != (member_inline_size <= 4) {
2738                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2739                }
2740                let inner_offset;
2741                let mut inner_depth = depth.clone();
2742                if inlined {
2743                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2744                    inner_offset = next_offset;
2745                } else {
2746                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2747                    inner_depth.increment()?;
2748                }
2749                let val_ref =
2750                self.container_job.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
2751                fidl::decode!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
2752                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2753                {
2754                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2755                }
2756                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2757                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2758                }
2759            }
2760
2761            next_offset += envelope_size;
2762            _next_ordinal_to_read += 1;
2763            if next_offset >= end_offset {
2764                return Ok(());
2765            }
2766
2767            // Decode unknown envelopes for gaps in ordinals.
2768            while _next_ordinal_to_read < 2 {
2769                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2770                _next_ordinal_to_read += 1;
2771                next_offset += envelope_size;
2772            }
2773
2774            let next_out_of_line = decoder.next_out_of_line();
2775            let handles_before = decoder.remaining_handles();
2776            if let Some((inlined, num_bytes, num_handles)) =
2777                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2778            {
2779                let member_inline_size = <fidl::encoding::HandleType<
2780                    fidl::EventPair,
2781                    { fidl::ObjectType::EVENTPAIR.into_raw() },
2782                    2147483648,
2783                > as fidl::encoding::TypeMarker>::inline_size(
2784                    decoder.context
2785                );
2786                if inlined != (member_inline_size <= 4) {
2787                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2788                }
2789                let inner_offset;
2790                let mut inner_depth = depth.clone();
2791                if inlined {
2792                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2793                    inner_offset = next_offset;
2794                } else {
2795                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2796                    inner_depth.increment()?;
2797                }
2798                let val_ref =
2799                self.wake_locks.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
2800                fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
2801                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2802                {
2803                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2804                }
2805                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2806                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2807                }
2808            }
2809
2810            next_offset += envelope_size;
2811
2812            // Decode the remaining unknown envelopes.
2813            while next_offset < end_offset {
2814                _next_ordinal_to_read += 1;
2815                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2816                next_offset += envelope_size;
2817            }
2818
2819            Ok(())
2820        }
2821    }
2822
2823    impl PagerRegisterFileResponse {
2824        #[inline(always)]
2825        fn max_ordinal_present(&self) -> u64 {
2826            if let Some(_) = self.vmo {
2827                return 1;
2828            }
2829            0
2830        }
2831    }
2832
2833    impl fidl::encoding::ResourceTypeMarker for PagerRegisterFileResponse {
2834        type Borrowed<'a> = &'a mut Self;
2835        fn take_or_borrow<'a>(
2836            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
2837        ) -> Self::Borrowed<'a> {
2838            value
2839        }
2840    }
2841
2842    unsafe impl fidl::encoding::TypeMarker for PagerRegisterFileResponse {
2843        type Owned = Self;
2844
2845        #[inline(always)]
2846        fn inline_align(_context: fidl::encoding::Context) -> usize {
2847            8
2848        }
2849
2850        #[inline(always)]
2851        fn inline_size(_context: fidl::encoding::Context) -> usize {
2852            16
2853        }
2854    }
2855
2856    unsafe impl
2857        fidl::encoding::Encode<
2858            PagerRegisterFileResponse,
2859            fidl::encoding::DefaultFuchsiaResourceDialect,
2860        > for &mut PagerRegisterFileResponse
2861    {
2862        unsafe fn encode(
2863            self,
2864            encoder: &mut fidl::encoding::Encoder<
2865                '_,
2866                fidl::encoding::DefaultFuchsiaResourceDialect,
2867            >,
2868            offset: usize,
2869            mut depth: fidl::encoding::Depth,
2870        ) -> fidl::Result<()> {
2871            encoder.debug_check_bounds::<PagerRegisterFileResponse>(offset);
2872            // Vector header
2873            let max_ordinal: u64 = self.max_ordinal_present();
2874            encoder.write_num(max_ordinal, offset);
2875            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2876            // Calling encoder.out_of_line_offset(0) is not allowed.
2877            if max_ordinal == 0 {
2878                return Ok(());
2879            }
2880            depth.increment()?;
2881            let envelope_size = 8;
2882            let bytes_len = max_ordinal as usize * envelope_size;
2883            #[allow(unused_variables)]
2884            let offset = encoder.out_of_line_offset(bytes_len);
2885            let mut _prev_end_offset: usize = 0;
2886            if 1 > max_ordinal {
2887                return Ok(());
2888            }
2889
2890            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2891            // are envelope_size bytes.
2892            let cur_offset: usize = (1 - 1) * envelope_size;
2893
2894            // Zero reserved fields.
2895            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2896
2897            // Safety:
2898            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2899            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2900            //   envelope_size bytes, there is always sufficient room.
2901            fidl::encoding::encode_in_envelope_optional::<
2902                fidl::encoding::HandleType<
2903                    fidl::Vmo,
2904                    { fidl::ObjectType::VMO.into_raw() },
2905                    2147483648,
2906                >,
2907                fidl::encoding::DefaultFuchsiaResourceDialect,
2908            >(
2909                self.vmo.as_mut().map(
2910                    <fidl::encoding::HandleType<
2911                        fidl::Vmo,
2912                        { fidl::ObjectType::VMO.into_raw() },
2913                        2147483648,
2914                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
2915                ),
2916                encoder,
2917                offset + cur_offset,
2918                depth,
2919            )?;
2920
2921            _prev_end_offset = cur_offset + envelope_size;
2922
2923            Ok(())
2924        }
2925    }
2926
2927    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
2928        for PagerRegisterFileResponse
2929    {
2930        #[inline(always)]
2931        fn new_empty() -> Self {
2932            Self::default()
2933        }
2934
2935        unsafe fn decode(
2936            &mut self,
2937            decoder: &mut fidl::encoding::Decoder<
2938                '_,
2939                fidl::encoding::DefaultFuchsiaResourceDialect,
2940            >,
2941            offset: usize,
2942            mut depth: fidl::encoding::Depth,
2943        ) -> fidl::Result<()> {
2944            decoder.debug_check_bounds::<Self>(offset);
2945            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2946                None => return Err(fidl::Error::NotNullable),
2947                Some(len) => len,
2948            };
2949            // Calling decoder.out_of_line_offset(0) is not allowed.
2950            if len == 0 {
2951                return Ok(());
2952            };
2953            depth.increment()?;
2954            let envelope_size = 8;
2955            let bytes_len = len * envelope_size;
2956            let offset = decoder.out_of_line_offset(bytes_len)?;
2957            // Decode the envelope for each type.
2958            let mut _next_ordinal_to_read = 0;
2959            let mut next_offset = offset;
2960            let end_offset = offset + bytes_len;
2961            _next_ordinal_to_read += 1;
2962            if next_offset >= end_offset {
2963                return Ok(());
2964            }
2965
2966            // Decode unknown envelopes for gaps in ordinals.
2967            while _next_ordinal_to_read < 1 {
2968                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2969                _next_ordinal_to_read += 1;
2970                next_offset += envelope_size;
2971            }
2972
2973            let next_out_of_line = decoder.next_out_of_line();
2974            let handles_before = decoder.remaining_handles();
2975            if let Some((inlined, num_bytes, num_handles)) =
2976                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2977            {
2978                let member_inline_size = <fidl::encoding::HandleType<
2979                    fidl::Vmo,
2980                    { fidl::ObjectType::VMO.into_raw() },
2981                    2147483648,
2982                > as fidl::encoding::TypeMarker>::inline_size(
2983                    decoder.context
2984                );
2985                if inlined != (member_inline_size <= 4) {
2986                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2987                }
2988                let inner_offset;
2989                let mut inner_depth = depth.clone();
2990                if inlined {
2991                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2992                    inner_offset = next_offset;
2993                } else {
2994                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2995                    inner_depth.increment()?;
2996                }
2997                let val_ref =
2998                self.vmo.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
2999                fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
3000                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3001                {
3002                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3003                }
3004                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3005                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3006                }
3007            }
3008
3009            next_offset += envelope_size;
3010
3011            // Decode the remaining unknown envelopes.
3012            while next_offset < end_offset {
3013                _next_ordinal_to_read += 1;
3014                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3015                next_offset += envelope_size;
3016            }
3017
3018            Ok(())
3019        }
3020    }
3021}