fidl_fuchsia_ui_test_conformance/
fidl_fuchsia_ui_test_conformance.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 _};
10use futures::future::{self, MaybeDone, TryFutureExt};
11use zx_status;
12
13/// Maximum number of filled rects a client can draw in a given image.
14pub const MAX_RECTS_PER_IMAGE: u32 = 1024;
15
16/// Defines the color of a piece of visual content.
17///
18/// We limit the palette to fully saturated colors to simplify verification
19/// with screenshots.
20#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
21pub enum Color {
22    /// 0x000000
23    Black,
24    /// 0xFF0000
25    Red,
26    /// 0x00FF00
27    Green,
28    /// 0x0000FF
29    Blue,
30    /// 0xFFFF00
31    Yellow,
32    /// 0xFF00FF
33    Magenta,
34    /// 0x00FFFF
35    Cyan,
36    /// 0xFFFFFF
37    White,
38    #[doc(hidden)]
39    __SourceBreaking { unknown_ordinal: u32 },
40}
41
42/// Pattern that matches an unknown `Color` member.
43#[macro_export]
44macro_rules! ColorUnknown {
45    () => {
46        _
47    };
48}
49
50impl Color {
51    #[inline]
52    pub fn from_primitive(prim: u32) -> Option<Self> {
53        match prim {
54            1 => Some(Self::Black),
55            2 => Some(Self::Red),
56            3 => Some(Self::Green),
57            4 => Some(Self::Blue),
58            5 => Some(Self::Yellow),
59            6 => Some(Self::Magenta),
60            7 => Some(Self::Cyan),
61            8 => Some(Self::White),
62            _ => None,
63        }
64    }
65
66    #[inline]
67    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
68        match prim {
69            1 => Self::Black,
70            2 => Self::Red,
71            3 => Self::Green,
72            4 => Self::Blue,
73            5 => Self::Yellow,
74            6 => Self::Magenta,
75            7 => Self::Cyan,
76            8 => Self::White,
77            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
78        }
79    }
80
81    #[inline]
82    pub fn unknown() -> Self {
83        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
84    }
85
86    #[inline]
87    pub const fn into_primitive(self) -> u32 {
88        match self {
89            Self::Black => 1,
90            Self::Red => 2,
91            Self::Green => 3,
92            Self::Blue => 4,
93            Self::Yellow => 5,
94            Self::Magenta => 6,
95            Self::Cyan => 7,
96            Self::White => 8,
97            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
98        }
99    }
100
101    #[inline]
102    pub fn is_unknown(&self) -> bool {
103        match self {
104            Self::__SourceBreaking { unknown_ordinal: _ } => true,
105            _ => false,
106        }
107    }
108}
109
110/// Result of a puppet operation.
111#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
112pub enum Result_ {
113    /// The puppet does not support the requested operation. This situation
114    /// may arise in several cases:
115    ///
116    /// 1. The runtime supports this operation, but the puppet has not yet
117    ///    implemented it.
118    /// 2. The runtime does not support this operation, and the puppet will
119    ///    never implement it.
120    /// 3. The puppet does not recognize this operation; this case may arise
121    ///    when new fields or methods are added to the Puppet protocol.
122    ///
123    /// A test will pass if the puppet returns UNSUPPORTED from any requested
124    /// operations.
125    Unsupported,
126    /// The puppet successfully completed the requested operation.
127    Success,
128    /// The puppet failed to complete the requested operation.
129    Error,
130    #[doc(hidden)]
131    __SourceBreaking { unknown_ordinal: u32 },
132}
133
134/// Pattern that matches an unknown `Result_` member.
135#[macro_export]
136macro_rules! Result_Unknown {
137    () => {
138        _
139    };
140}
141
142impl Result_ {
143    #[inline]
144    pub fn from_primitive(prim: u32) -> Option<Self> {
145        match prim {
146            0 => Some(Self::Unsupported),
147            1 => Some(Self::Success),
148            2 => Some(Self::Error),
149            _ => None,
150        }
151    }
152
153    #[inline]
154    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
155        match prim {
156            0 => Self::Unsupported,
157            1 => Self::Success,
158            2 => Self::Error,
159            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
160        }
161    }
162
163    #[inline]
164    pub fn unknown() -> Self {
165        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
166    }
167
168    #[inline]
169    pub const fn into_primitive(self) -> u32 {
170        match self {
171            Self::Unsupported => 0,
172            Self::Success => 1,
173            Self::Error => 2,
174            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
175        }
176    }
177
178    #[inline]
179    pub fn is_unknown(&self) -> bool {
180        match self {
181            Self::__SourceBreaking { unknown_ordinal: _ } => true,
182            _ => false,
183        }
184    }
185}
186
187/// Defines the size and position of a piece of graphical content.
188///
189/// The bounds of the content are assumed to be rectangular.
190#[derive(Clone, Debug, Default, PartialEq)]
191pub struct ContentBounds {
192    /// The size of the content, defined in its parent view's coordinate space.
193    ///
194    /// For example, a parent view with size 1280x800 is assumed to have a
195    /// useful coordinate space from (0, 0) to (1280, 800). A piece of content
196    /// that's one-fourth the area of the parent view would have size 640x400.
197    pub size: Option<fidl_fuchsia_math::SizeU>,
198    /// The location of the top-left corner of the content's origin, defined in
199    /// the parent view's coordinate space.
200    ///
201    /// Returning to the example above, we could position the content to cover
202    /// the bottom-right quadrant of the parent by assigning an origin of
203    /// (640, 400).
204    pub origin: Option<fidl_fuchsia_math::Vec_>,
205    #[doc(hidden)]
206    pub __source_breaking: fidl::marker::SourceBreaking,
207}
208
209impl fidl::Persistable for ContentBounds {}
210
211/// Describes an embedded view.
212#[derive(Clone, Debug, Default, PartialEq)]
213pub struct EmbeddedViewProperties {
214    /// The embedded view's bounds, defined in the parent view's coordinate
215    /// space.
216    pub bounds: Option<ContentBounds>,
217    #[doc(hidden)]
218    pub __source_breaking: fidl::marker::SourceBreaking,
219}
220
221impl fidl::Persistable for EmbeddedViewProperties {}
222
223/// Describes a rectangle with a solid, monochrome fill.
224#[derive(Clone, Debug, Default, PartialEq)]
225pub struct FilledRect {
226    /// The color of the rectangle's fill.
227    pub color: Option<Color>,
228    /// The rectangle's bounds, defined in the parent view's coordinate space.
229    pub bounds: Option<ContentBounds>,
230    #[doc(hidden)]
231    pub __source_breaking: fidl::marker::SourceBreaking,
232}
233
234impl fidl::Persistable for FilledRect {}
235
236/// Describes a piece of visual content.
237#[derive(Clone, Debug, Default, PartialEq)]
238pub struct ImageProperties {
239    /// The image's bounds, defined in the parent view's coordinate space.
240    pub bounds: Option<ContentBounds>,
241    /// Describes the contents of the image. Rects are considered to be in
242    /// reverse z-order, i.e. successive elements are drawn on top of their
243    /// predecessors.
244    pub filled_rects: Option<Vec<FilledRect>>,
245    #[doc(hidden)]
246    pub __source_breaking: fidl::marker::SourceBreaking,
247}
248
249impl fidl::Persistable for ImageProperties {}
250
251/// Used to create a puppet instance.
252#[derive(Debug, Default, PartialEq)]
253pub struct PuppetCreationArgs {
254    pub server_end: Option<fidl::endpoints::ServerEnd<PuppetMarker>>,
255    pub view_token: Option<fidl_fuchsia_ui_views::ViewCreationToken>,
256    pub touch_listener:
257        Option<fidl::endpoints::ClientEnd<fidl_fuchsia_ui_test_input::TouchInputListenerMarker>>,
258    pub mouse_listener:
259        Option<fidl::endpoints::ClientEnd<fidl_fuchsia_ui_test_input::MouseInputListenerMarker>>,
260    pub keyboard_listener:
261        Option<fidl::endpoints::ClientEnd<fidl_fuchsia_ui_test_input::KeyboardInputListenerMarker>>,
262    pub flatland_client:
263        Option<fidl::endpoints::ClientEnd<fidl_fuchsia_ui_composition::FlatlandMarker>>,
264    pub keyboard_client: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardMarker>>,
265    pub device_pixel_ratio: Option<f32>,
266    pub focuser: Option<fidl::endpoints::ServerEnd<fidl_fuchsia_ui_views::FocuserMarker>>,
267    #[doc(hidden)]
268    pub __source_breaking: fidl::marker::SourceBreaking,
269}
270
271impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for PuppetCreationArgs {}
272
273#[derive(Clone, Debug, Default, PartialEq)]
274pub struct PuppetDrawImageRequest {
275    pub id: Option<u64>,
276    pub properties: Option<ImageProperties>,
277    #[doc(hidden)]
278    pub __source_breaking: fidl::marker::SourceBreaking,
279}
280
281impl fidl::Persistable for PuppetDrawImageRequest {}
282
283#[derive(Clone, Debug, Default, PartialEq)]
284pub struct PuppetDrawImageResponse {
285    pub result: Option<Result_>,
286    #[doc(hidden)]
287    pub __source_breaking: fidl::marker::SourceBreaking,
288}
289
290impl fidl::Persistable for PuppetDrawImageResponse {}
291
292#[derive(Clone, Debug, Default, PartialEq)]
293pub struct PuppetEmbedRemoteViewRequest {
294    pub id: Option<u64>,
295    pub properties: Option<EmbeddedViewProperties>,
296    #[doc(hidden)]
297    pub __source_breaking: fidl::marker::SourceBreaking,
298}
299
300impl fidl::Persistable for PuppetEmbedRemoteViewRequest {}
301
302#[derive(Debug, Default, PartialEq)]
303pub struct PuppetEmbedRemoteViewResponse {
304    pub result: Option<Result_>,
305    pub view_creation_token: Option<fidl_fuchsia_ui_views::ViewCreationToken>,
306    #[doc(hidden)]
307    pub __source_breaking: fidl::marker::SourceBreaking,
308}
309
310impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
311    for PuppetEmbedRemoteViewResponse
312{
313}
314
315#[derive(Debug, Default, PartialEq)]
316pub struct PuppetFactoryCreateResponse {
317    pub result: Option<Result_>,
318    /// view_ref of the created view.
319    pub view_ref: Option<fidl_fuchsia_ui_views::ViewRef>,
320    #[doc(hidden)]
321    pub __source_breaking: fidl::marker::SourceBreaking,
322}
323
324impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
325    for PuppetFactoryCreateResponse
326{
327}
328
329#[derive(Clone, Debug, Default, PartialEq)]
330pub struct PuppetSetEmbeddedViewPropertiesRequest {
331    pub id: Option<u64>,
332    pub properties: Option<EmbeddedViewProperties>,
333    #[doc(hidden)]
334    pub __source_breaking: fidl::marker::SourceBreaking,
335}
336
337impl fidl::Persistable for PuppetSetEmbeddedViewPropertiesRequest {}
338
339#[derive(Clone, Debug, Default, PartialEq)]
340pub struct PuppetSetEmbeddedViewPropertiesResponse {
341    pub result: Option<Result_>,
342    #[doc(hidden)]
343    pub __source_breaking: fidl::marker::SourceBreaking,
344}
345
346impl fidl::Persistable for PuppetSetEmbeddedViewPropertiesResponse {}
347
348#[derive(Clone, Debug, Default, PartialEq)]
349pub struct PuppetSetImagePropertiesRequest {
350    pub id: Option<u64>,
351    pub properties: Option<ImageProperties>,
352    #[doc(hidden)]
353    pub __source_breaking: fidl::marker::SourceBreaking,
354}
355
356impl fidl::Persistable for PuppetSetImagePropertiesRequest {}
357
358#[derive(Clone, Debug, Default, PartialEq)]
359pub struct PuppetSetImagePropertiesResponse {
360    pub result: Option<Result_>,
361    #[doc(hidden)]
362    pub __source_breaking: fidl::marker::SourceBreaking,
363}
364
365impl fidl::Persistable for PuppetSetImagePropertiesResponse {}
366
367#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
368pub struct PuppetMarker;
369
370impl fidl::endpoints::ProtocolMarker for PuppetMarker {
371    type Proxy = PuppetProxy;
372    type RequestStream = PuppetRequestStream;
373    #[cfg(target_os = "fuchsia")]
374    type SynchronousProxy = PuppetSynchronousProxy;
375
376    const DEBUG_NAME: &'static str = "(anonymous) Puppet";
377}
378
379pub trait PuppetProxyInterface: Send + Sync {
380    type EmbedRemoteViewResponseFut: std::future::Future<Output = Result<PuppetEmbedRemoteViewResponse, fidl::Error>>
381        + Send;
382    fn r#embed_remote_view(
383        &self,
384        payload: &PuppetEmbedRemoteViewRequest,
385    ) -> Self::EmbedRemoteViewResponseFut;
386    type SetEmbeddedViewPropertiesResponseFut: std::future::Future<Output = Result<PuppetSetEmbeddedViewPropertiesResponse, fidl::Error>>
387        + Send;
388    fn r#set_embedded_view_properties(
389        &self,
390        payload: &PuppetSetEmbeddedViewPropertiesRequest,
391    ) -> Self::SetEmbeddedViewPropertiesResponseFut;
392    type DrawImageResponseFut: std::future::Future<Output = Result<PuppetDrawImageResponse, fidl::Error>>
393        + Send;
394    fn r#draw_image(&self, payload: &PuppetDrawImageRequest) -> Self::DrawImageResponseFut;
395    type SetImagePropertiesResponseFut: std::future::Future<Output = Result<PuppetSetImagePropertiesResponse, fidl::Error>>
396        + Send;
397    fn r#set_image_properties(
398        &self,
399        payload: &PuppetSetImagePropertiesRequest,
400    ) -> Self::SetImagePropertiesResponseFut;
401}
402#[derive(Debug)]
403#[cfg(target_os = "fuchsia")]
404pub struct PuppetSynchronousProxy {
405    client: fidl::client::sync::Client,
406}
407
408#[cfg(target_os = "fuchsia")]
409impl fidl::endpoints::SynchronousProxy for PuppetSynchronousProxy {
410    type Proxy = PuppetProxy;
411    type Protocol = PuppetMarker;
412
413    fn from_channel(inner: fidl::Channel) -> Self {
414        Self::new(inner)
415    }
416
417    fn into_channel(self) -> fidl::Channel {
418        self.client.into_channel()
419    }
420
421    fn as_channel(&self) -> &fidl::Channel {
422        self.client.as_channel()
423    }
424}
425
426#[cfg(target_os = "fuchsia")]
427impl PuppetSynchronousProxy {
428    pub fn new(channel: fidl::Channel) -> Self {
429        let protocol_name = <PuppetMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
430        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
431    }
432
433    pub fn into_channel(self) -> fidl::Channel {
434        self.client.into_channel()
435    }
436
437    /// Waits until an event arrives and returns it. It is safe for other
438    /// threads to make concurrent requests while waiting for an event.
439    pub fn wait_for_event(
440        &self,
441        deadline: zx::MonotonicInstant,
442    ) -> Result<PuppetEvent, fidl::Error> {
443        PuppetEvent::decode(self.client.wait_for_event(deadline)?)
444    }
445
446    /// Embeds a view owned elsewhere.
447    ///
448    /// The puppet should create a (ViewportCreationToken, ViewCreationToken) pair
449    /// and use the former to create a viewport with the specified `properties`.
450    /// Once the puppet has presented a frame containing the new viewport, it should
451    /// return the view creation token to the caller.
452    pub fn r#embed_remote_view(
453        &self,
454        mut payload: &PuppetEmbedRemoteViewRequest,
455        ___deadline: zx::MonotonicInstant,
456    ) -> Result<PuppetEmbedRemoteViewResponse, fidl::Error> {
457        let _response =
458            self.client.send_query::<PuppetEmbedRemoteViewRequest, PuppetEmbedRemoteViewResponse>(
459                payload,
460                0x5bb2325a988aa137,
461                fidl::encoding::DynamicFlags::empty(),
462                ___deadline,
463            )?;
464        Ok(_response)
465    }
466
467    /// Updates the properties of an embedded view.
468    pub fn r#set_embedded_view_properties(
469        &self,
470        mut payload: &PuppetSetEmbeddedViewPropertiesRequest,
471        ___deadline: zx::MonotonicInstant,
472    ) -> Result<PuppetSetEmbeddedViewPropertiesResponse, fidl::Error> {
473        let _response = self.client.send_query::<
474            PuppetSetEmbeddedViewPropertiesRequest,
475            PuppetSetEmbeddedViewPropertiesResponse,
476        >(
477            payload,
478            0x409a7f3de135c709,
479            fidl::encoding::DynamicFlags::empty(),
480            ___deadline,
481        )?;
482        Ok(_response)
483    }
484
485    /// Draws an image composed of solid, monochrome-filled rectangles.
486    pub fn r#draw_image(
487        &self,
488        mut payload: &PuppetDrawImageRequest,
489        ___deadline: zx::MonotonicInstant,
490    ) -> Result<PuppetDrawImageResponse, fidl::Error> {
491        let _response = self.client.send_query::<PuppetDrawImageRequest, PuppetDrawImageResponse>(
492            payload,
493            0x6d736daa48b835cc,
494            fidl::encoding::DynamicFlags::empty(),
495            ___deadline,
496        )?;
497        Ok(_response)
498    }
499
500    /// Updates the properties of an image.
501    pub fn r#set_image_properties(
502        &self,
503        mut payload: &PuppetSetImagePropertiesRequest,
504        ___deadline: zx::MonotonicInstant,
505    ) -> Result<PuppetSetImagePropertiesResponse, fidl::Error> {
506        let _response = self
507            .client
508            .send_query::<PuppetSetImagePropertiesRequest, PuppetSetImagePropertiesResponse>(
509                payload,
510                0x2683795408d033ff,
511                fidl::encoding::DynamicFlags::empty(),
512                ___deadline,
513            )?;
514        Ok(_response)
515    }
516}
517
518#[derive(Debug, Clone)]
519pub struct PuppetProxy {
520    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
521}
522
523impl fidl::endpoints::Proxy for PuppetProxy {
524    type Protocol = PuppetMarker;
525
526    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
527        Self::new(inner)
528    }
529
530    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
531        self.client.into_channel().map_err(|client| Self { client })
532    }
533
534    fn as_channel(&self) -> &::fidl::AsyncChannel {
535        self.client.as_channel()
536    }
537}
538
539impl PuppetProxy {
540    /// Create a new Proxy for fuchsia.ui.test.conformance/Puppet.
541    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
542        let protocol_name = <PuppetMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
543        Self { client: fidl::client::Client::new(channel, protocol_name) }
544    }
545
546    /// Get a Stream of events from the remote end of the protocol.
547    ///
548    /// # Panics
549    ///
550    /// Panics if the event stream was already taken.
551    pub fn take_event_stream(&self) -> PuppetEventStream {
552        PuppetEventStream { event_receiver: self.client.take_event_receiver() }
553    }
554
555    /// Embeds a view owned elsewhere.
556    ///
557    /// The puppet should create a (ViewportCreationToken, ViewCreationToken) pair
558    /// and use the former to create a viewport with the specified `properties`.
559    /// Once the puppet has presented a frame containing the new viewport, it should
560    /// return the view creation token to the caller.
561    pub fn r#embed_remote_view(
562        &self,
563        mut payload: &PuppetEmbedRemoteViewRequest,
564    ) -> fidl::client::QueryResponseFut<
565        PuppetEmbedRemoteViewResponse,
566        fidl::encoding::DefaultFuchsiaResourceDialect,
567    > {
568        PuppetProxyInterface::r#embed_remote_view(self, payload)
569    }
570
571    /// Updates the properties of an embedded view.
572    pub fn r#set_embedded_view_properties(
573        &self,
574        mut payload: &PuppetSetEmbeddedViewPropertiesRequest,
575    ) -> fidl::client::QueryResponseFut<
576        PuppetSetEmbeddedViewPropertiesResponse,
577        fidl::encoding::DefaultFuchsiaResourceDialect,
578    > {
579        PuppetProxyInterface::r#set_embedded_view_properties(self, payload)
580    }
581
582    /// Draws an image composed of solid, monochrome-filled rectangles.
583    pub fn r#draw_image(
584        &self,
585        mut payload: &PuppetDrawImageRequest,
586    ) -> fidl::client::QueryResponseFut<
587        PuppetDrawImageResponse,
588        fidl::encoding::DefaultFuchsiaResourceDialect,
589    > {
590        PuppetProxyInterface::r#draw_image(self, payload)
591    }
592
593    /// Updates the properties of an image.
594    pub fn r#set_image_properties(
595        &self,
596        mut payload: &PuppetSetImagePropertiesRequest,
597    ) -> fidl::client::QueryResponseFut<
598        PuppetSetImagePropertiesResponse,
599        fidl::encoding::DefaultFuchsiaResourceDialect,
600    > {
601        PuppetProxyInterface::r#set_image_properties(self, payload)
602    }
603}
604
605impl PuppetProxyInterface for PuppetProxy {
606    type EmbedRemoteViewResponseFut = fidl::client::QueryResponseFut<
607        PuppetEmbedRemoteViewResponse,
608        fidl::encoding::DefaultFuchsiaResourceDialect,
609    >;
610    fn r#embed_remote_view(
611        &self,
612        mut payload: &PuppetEmbedRemoteViewRequest,
613    ) -> Self::EmbedRemoteViewResponseFut {
614        fn _decode(
615            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
616        ) -> Result<PuppetEmbedRemoteViewResponse, fidl::Error> {
617            let _response = fidl::client::decode_transaction_body::<
618                PuppetEmbedRemoteViewResponse,
619                fidl::encoding::DefaultFuchsiaResourceDialect,
620                0x5bb2325a988aa137,
621            >(_buf?)?;
622            Ok(_response)
623        }
624        self.client
625            .send_query_and_decode::<PuppetEmbedRemoteViewRequest, PuppetEmbedRemoteViewResponse>(
626                payload,
627                0x5bb2325a988aa137,
628                fidl::encoding::DynamicFlags::empty(),
629                _decode,
630            )
631    }
632
633    type SetEmbeddedViewPropertiesResponseFut = fidl::client::QueryResponseFut<
634        PuppetSetEmbeddedViewPropertiesResponse,
635        fidl::encoding::DefaultFuchsiaResourceDialect,
636    >;
637    fn r#set_embedded_view_properties(
638        &self,
639        mut payload: &PuppetSetEmbeddedViewPropertiesRequest,
640    ) -> Self::SetEmbeddedViewPropertiesResponseFut {
641        fn _decode(
642            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
643        ) -> Result<PuppetSetEmbeddedViewPropertiesResponse, fidl::Error> {
644            let _response = fidl::client::decode_transaction_body::<
645                PuppetSetEmbeddedViewPropertiesResponse,
646                fidl::encoding::DefaultFuchsiaResourceDialect,
647                0x409a7f3de135c709,
648            >(_buf?)?;
649            Ok(_response)
650        }
651        self.client.send_query_and_decode::<
652            PuppetSetEmbeddedViewPropertiesRequest,
653            PuppetSetEmbeddedViewPropertiesResponse,
654        >(
655            payload,
656            0x409a7f3de135c709,
657            fidl::encoding::DynamicFlags::empty(),
658            _decode,
659        )
660    }
661
662    type DrawImageResponseFut = fidl::client::QueryResponseFut<
663        PuppetDrawImageResponse,
664        fidl::encoding::DefaultFuchsiaResourceDialect,
665    >;
666    fn r#draw_image(&self, mut payload: &PuppetDrawImageRequest) -> Self::DrawImageResponseFut {
667        fn _decode(
668            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
669        ) -> Result<PuppetDrawImageResponse, fidl::Error> {
670            let _response = fidl::client::decode_transaction_body::<
671                PuppetDrawImageResponse,
672                fidl::encoding::DefaultFuchsiaResourceDialect,
673                0x6d736daa48b835cc,
674            >(_buf?)?;
675            Ok(_response)
676        }
677        self.client.send_query_and_decode::<PuppetDrawImageRequest, PuppetDrawImageResponse>(
678            payload,
679            0x6d736daa48b835cc,
680            fidl::encoding::DynamicFlags::empty(),
681            _decode,
682        )
683    }
684
685    type SetImagePropertiesResponseFut = fidl::client::QueryResponseFut<
686        PuppetSetImagePropertiesResponse,
687        fidl::encoding::DefaultFuchsiaResourceDialect,
688    >;
689    fn r#set_image_properties(
690        &self,
691        mut payload: &PuppetSetImagePropertiesRequest,
692    ) -> Self::SetImagePropertiesResponseFut {
693        fn _decode(
694            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
695        ) -> Result<PuppetSetImagePropertiesResponse, fidl::Error> {
696            let _response = fidl::client::decode_transaction_body::<
697                PuppetSetImagePropertiesResponse,
698                fidl::encoding::DefaultFuchsiaResourceDialect,
699                0x2683795408d033ff,
700            >(_buf?)?;
701            Ok(_response)
702        }
703        self.client.send_query_and_decode::<
704            PuppetSetImagePropertiesRequest,
705            PuppetSetImagePropertiesResponse,
706        >(
707            payload,
708            0x2683795408d033ff,
709            fidl::encoding::DynamicFlags::empty(),
710            _decode,
711        )
712    }
713}
714
715pub struct PuppetEventStream {
716    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
717}
718
719impl std::marker::Unpin for PuppetEventStream {}
720
721impl futures::stream::FusedStream for PuppetEventStream {
722    fn is_terminated(&self) -> bool {
723        self.event_receiver.is_terminated()
724    }
725}
726
727impl futures::Stream for PuppetEventStream {
728    type Item = Result<PuppetEvent, fidl::Error>;
729
730    fn poll_next(
731        mut self: std::pin::Pin<&mut Self>,
732        cx: &mut std::task::Context<'_>,
733    ) -> std::task::Poll<Option<Self::Item>> {
734        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
735            &mut self.event_receiver,
736            cx
737        )?) {
738            Some(buf) => std::task::Poll::Ready(Some(PuppetEvent::decode(buf))),
739            None => std::task::Poll::Ready(None),
740        }
741    }
742}
743
744#[derive(Debug)]
745pub enum PuppetEvent {}
746
747impl PuppetEvent {
748    /// Decodes a message buffer as a [`PuppetEvent`].
749    fn decode(
750        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
751    ) -> Result<PuppetEvent, fidl::Error> {
752        let (bytes, _handles) = buf.split_mut();
753        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
754        debug_assert_eq!(tx_header.tx_id, 0);
755        match tx_header.ordinal {
756            _ => Err(fidl::Error::UnknownOrdinal {
757                ordinal: tx_header.ordinal,
758                protocol_name: <PuppetMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
759            }),
760        }
761    }
762}
763
764/// A Stream of incoming requests for fuchsia.ui.test.conformance/Puppet.
765pub struct PuppetRequestStream {
766    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
767    is_terminated: bool,
768}
769
770impl std::marker::Unpin for PuppetRequestStream {}
771
772impl futures::stream::FusedStream for PuppetRequestStream {
773    fn is_terminated(&self) -> bool {
774        self.is_terminated
775    }
776}
777
778impl fidl::endpoints::RequestStream for PuppetRequestStream {
779    type Protocol = PuppetMarker;
780    type ControlHandle = PuppetControlHandle;
781
782    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
783        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
784    }
785
786    fn control_handle(&self) -> Self::ControlHandle {
787        PuppetControlHandle { inner: self.inner.clone() }
788    }
789
790    fn into_inner(
791        self,
792    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
793    {
794        (self.inner, self.is_terminated)
795    }
796
797    fn from_inner(
798        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
799        is_terminated: bool,
800    ) -> Self {
801        Self { inner, is_terminated }
802    }
803}
804
805impl futures::Stream for PuppetRequestStream {
806    type Item = Result<PuppetRequest, fidl::Error>;
807
808    fn poll_next(
809        mut self: std::pin::Pin<&mut Self>,
810        cx: &mut std::task::Context<'_>,
811    ) -> std::task::Poll<Option<Self::Item>> {
812        let this = &mut *self;
813        if this.inner.check_shutdown(cx) {
814            this.is_terminated = true;
815            return std::task::Poll::Ready(None);
816        }
817        if this.is_terminated {
818            panic!("polled PuppetRequestStream after completion");
819        }
820        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
821            |bytes, handles| {
822                match this.inner.channel().read_etc(cx, bytes, handles) {
823                    std::task::Poll::Ready(Ok(())) => {}
824                    std::task::Poll::Pending => return std::task::Poll::Pending,
825                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
826                        this.is_terminated = true;
827                        return std::task::Poll::Ready(None);
828                    }
829                    std::task::Poll::Ready(Err(e)) => {
830                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
831                            e.into(),
832                        ))))
833                    }
834                }
835
836                // A message has been received from the channel
837                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
838
839                std::task::Poll::Ready(Some(match header.ordinal {
840                    0x5bb2325a988aa137 => {
841                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
842                        let mut req = fidl::new_empty!(
843                            PuppetEmbedRemoteViewRequest,
844                            fidl::encoding::DefaultFuchsiaResourceDialect
845                        );
846                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PuppetEmbedRemoteViewRequest>(&header, _body_bytes, handles, &mut req)?;
847                        let control_handle = PuppetControlHandle { inner: this.inner.clone() };
848                        Ok(PuppetRequest::EmbedRemoteView {
849                            payload: req,
850                            responder: PuppetEmbedRemoteViewResponder {
851                                control_handle: std::mem::ManuallyDrop::new(control_handle),
852                                tx_id: header.tx_id,
853                            },
854                        })
855                    }
856                    0x409a7f3de135c709 => {
857                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
858                        let mut req = fidl::new_empty!(
859                            PuppetSetEmbeddedViewPropertiesRequest,
860                            fidl::encoding::DefaultFuchsiaResourceDialect
861                        );
862                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PuppetSetEmbeddedViewPropertiesRequest>(&header, _body_bytes, handles, &mut req)?;
863                        let control_handle = PuppetControlHandle { inner: this.inner.clone() };
864                        Ok(PuppetRequest::SetEmbeddedViewProperties {
865                            payload: req,
866                            responder: PuppetSetEmbeddedViewPropertiesResponder {
867                                control_handle: std::mem::ManuallyDrop::new(control_handle),
868                                tx_id: header.tx_id,
869                            },
870                        })
871                    }
872                    0x6d736daa48b835cc => {
873                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
874                        let mut req = fidl::new_empty!(
875                            PuppetDrawImageRequest,
876                            fidl::encoding::DefaultFuchsiaResourceDialect
877                        );
878                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PuppetDrawImageRequest>(&header, _body_bytes, handles, &mut req)?;
879                        let control_handle = PuppetControlHandle { inner: this.inner.clone() };
880                        Ok(PuppetRequest::DrawImage {
881                            payload: req,
882                            responder: PuppetDrawImageResponder {
883                                control_handle: std::mem::ManuallyDrop::new(control_handle),
884                                tx_id: header.tx_id,
885                            },
886                        })
887                    }
888                    0x2683795408d033ff => {
889                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
890                        let mut req = fidl::new_empty!(
891                            PuppetSetImagePropertiesRequest,
892                            fidl::encoding::DefaultFuchsiaResourceDialect
893                        );
894                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PuppetSetImagePropertiesRequest>(&header, _body_bytes, handles, &mut req)?;
895                        let control_handle = PuppetControlHandle { inner: this.inner.clone() };
896                        Ok(PuppetRequest::SetImageProperties {
897                            payload: req,
898                            responder: PuppetSetImagePropertiesResponder {
899                                control_handle: std::mem::ManuallyDrop::new(control_handle),
900                                tx_id: header.tx_id,
901                            },
902                        })
903                    }
904                    _ => Err(fidl::Error::UnknownOrdinal {
905                        ordinal: header.ordinal,
906                        protocol_name:
907                            <PuppetMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
908                    }),
909                }))
910            },
911        )
912    }
913}
914
915/// ******************************* PLEASE READ *******************************
916///
917/// A tool to help developers write generalizable tests against a well-defined
918/// client application ("the puppet"). This API is not intended to cover every
919/// possible UI platform API use case.
920///
921/// TOPOLOGY
922///
923/// Each puppet is assumed to own exactly one view.
924///
925/// Each piece of content added is assumed to be a "direct child" of this view;
926/// and a sibling of the rest of the view's contents. In other words, all
927/// embedded views, filled rects, etc. are considered to have "sibling" semantics;
928/// for example, repositioning or resizing one piece of content should not
929/// reposition/resize any other piece of content.
930///
931/// Z-ORDERING
932///
933/// The contents of a puppet's view are z-ordered according to the order in which
934/// they were created. The first piece of content created appears at the "bottom",
935/// and the last piece of content created appears at the "top".
936///
937/// IDS
938///
939/// All ids must be globally unique, e.g. a "filled rect" id belongs to the same
940/// id space as an "embedded view" id.
941///
942/// SYNCHRONIZATION
943///
944/// All methods should block until the frame containing the requested changes has
945/// rendered to the display, if a new frame is required.
946///
947/// RETURN VALUES
948///
949/// See documentation on the `Result` enum above.
950///
951/// UNKNOWN INTERACTIONS
952///
953/// Puppet implementations may live outside of fuchsia.git, so they will encounter
954/// unknown methods and/or fields any time we extend the puppet API. In these cases,
955/// the puppet should always return `UNSUPPORTED`.
956#[derive(Debug)]
957pub enum PuppetRequest {
958    /// Embeds a view owned elsewhere.
959    ///
960    /// The puppet should create a (ViewportCreationToken, ViewCreationToken) pair
961    /// and use the former to create a viewport with the specified `properties`.
962    /// Once the puppet has presented a frame containing the new viewport, it should
963    /// return the view creation token to the caller.
964    EmbedRemoteView {
965        payload: PuppetEmbedRemoteViewRequest,
966        responder: PuppetEmbedRemoteViewResponder,
967    },
968    /// Updates the properties of an embedded view.
969    SetEmbeddedViewProperties {
970        payload: PuppetSetEmbeddedViewPropertiesRequest,
971        responder: PuppetSetEmbeddedViewPropertiesResponder,
972    },
973    /// Draws an image composed of solid, monochrome-filled rectangles.
974    DrawImage { payload: PuppetDrawImageRequest, responder: PuppetDrawImageResponder },
975    /// Updates the properties of an image.
976    SetImageProperties {
977        payload: PuppetSetImagePropertiesRequest,
978        responder: PuppetSetImagePropertiesResponder,
979    },
980}
981
982impl PuppetRequest {
983    #[allow(irrefutable_let_patterns)]
984    pub fn into_embed_remote_view(
985        self,
986    ) -> Option<(PuppetEmbedRemoteViewRequest, PuppetEmbedRemoteViewResponder)> {
987        if let PuppetRequest::EmbedRemoteView { payload, responder } = self {
988            Some((payload, responder))
989        } else {
990            None
991        }
992    }
993
994    #[allow(irrefutable_let_patterns)]
995    pub fn into_set_embedded_view_properties(
996        self,
997    ) -> Option<(PuppetSetEmbeddedViewPropertiesRequest, PuppetSetEmbeddedViewPropertiesResponder)>
998    {
999        if let PuppetRequest::SetEmbeddedViewProperties { payload, responder } = self {
1000            Some((payload, responder))
1001        } else {
1002            None
1003        }
1004    }
1005
1006    #[allow(irrefutable_let_patterns)]
1007    pub fn into_draw_image(self) -> Option<(PuppetDrawImageRequest, PuppetDrawImageResponder)> {
1008        if let PuppetRequest::DrawImage { payload, responder } = self {
1009            Some((payload, responder))
1010        } else {
1011            None
1012        }
1013    }
1014
1015    #[allow(irrefutable_let_patterns)]
1016    pub fn into_set_image_properties(
1017        self,
1018    ) -> Option<(PuppetSetImagePropertiesRequest, PuppetSetImagePropertiesResponder)> {
1019        if let PuppetRequest::SetImageProperties { payload, responder } = self {
1020            Some((payload, responder))
1021        } else {
1022            None
1023        }
1024    }
1025
1026    /// Name of the method defined in FIDL
1027    pub fn method_name(&self) -> &'static str {
1028        match *self {
1029            PuppetRequest::EmbedRemoteView { .. } => "embed_remote_view",
1030            PuppetRequest::SetEmbeddedViewProperties { .. } => "set_embedded_view_properties",
1031            PuppetRequest::DrawImage { .. } => "draw_image",
1032            PuppetRequest::SetImageProperties { .. } => "set_image_properties",
1033        }
1034    }
1035}
1036
1037#[derive(Debug, Clone)]
1038pub struct PuppetControlHandle {
1039    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1040}
1041
1042impl fidl::endpoints::ControlHandle for PuppetControlHandle {
1043    fn shutdown(&self) {
1044        self.inner.shutdown()
1045    }
1046    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1047        self.inner.shutdown_with_epitaph(status)
1048    }
1049
1050    fn is_closed(&self) -> bool {
1051        self.inner.channel().is_closed()
1052    }
1053    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1054        self.inner.channel().on_closed()
1055    }
1056
1057    #[cfg(target_os = "fuchsia")]
1058    fn signal_peer(
1059        &self,
1060        clear_mask: zx::Signals,
1061        set_mask: zx::Signals,
1062    ) -> Result<(), zx_status::Status> {
1063        use fidl::Peered;
1064        self.inner.channel().signal_peer(clear_mask, set_mask)
1065    }
1066}
1067
1068impl PuppetControlHandle {}
1069
1070#[must_use = "FIDL methods require a response to be sent"]
1071#[derive(Debug)]
1072pub struct PuppetEmbedRemoteViewResponder {
1073    control_handle: std::mem::ManuallyDrop<PuppetControlHandle>,
1074    tx_id: u32,
1075}
1076
1077/// Set the the channel to be shutdown (see [`PuppetControlHandle::shutdown`])
1078/// if the responder is dropped without sending a response, so that the client
1079/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1080impl std::ops::Drop for PuppetEmbedRemoteViewResponder {
1081    fn drop(&mut self) {
1082        self.control_handle.shutdown();
1083        // Safety: drops once, never accessed again
1084        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1085    }
1086}
1087
1088impl fidl::endpoints::Responder for PuppetEmbedRemoteViewResponder {
1089    type ControlHandle = PuppetControlHandle;
1090
1091    fn control_handle(&self) -> &PuppetControlHandle {
1092        &self.control_handle
1093    }
1094
1095    fn drop_without_shutdown(mut self) {
1096        // Safety: drops once, never accessed again due to mem::forget
1097        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1098        // Prevent Drop from running (which would shut down the channel)
1099        std::mem::forget(self);
1100    }
1101}
1102
1103impl PuppetEmbedRemoteViewResponder {
1104    /// Sends a response to the FIDL transaction.
1105    ///
1106    /// Sets the channel to shutdown if an error occurs.
1107    pub fn send(self, mut payload: PuppetEmbedRemoteViewResponse) -> Result<(), fidl::Error> {
1108        let _result = self.send_raw(payload);
1109        if _result.is_err() {
1110            self.control_handle.shutdown();
1111        }
1112        self.drop_without_shutdown();
1113        _result
1114    }
1115
1116    /// Similar to "send" but does not shutdown the channel if an error occurs.
1117    pub fn send_no_shutdown_on_err(
1118        self,
1119        mut payload: PuppetEmbedRemoteViewResponse,
1120    ) -> Result<(), fidl::Error> {
1121        let _result = self.send_raw(payload);
1122        self.drop_without_shutdown();
1123        _result
1124    }
1125
1126    fn send_raw(&self, mut payload: PuppetEmbedRemoteViewResponse) -> Result<(), fidl::Error> {
1127        self.control_handle.inner.send::<PuppetEmbedRemoteViewResponse>(
1128            &mut payload,
1129            self.tx_id,
1130            0x5bb2325a988aa137,
1131            fidl::encoding::DynamicFlags::empty(),
1132        )
1133    }
1134}
1135
1136#[must_use = "FIDL methods require a response to be sent"]
1137#[derive(Debug)]
1138pub struct PuppetSetEmbeddedViewPropertiesResponder {
1139    control_handle: std::mem::ManuallyDrop<PuppetControlHandle>,
1140    tx_id: u32,
1141}
1142
1143/// Set the the channel to be shutdown (see [`PuppetControlHandle::shutdown`])
1144/// if the responder is dropped without sending a response, so that the client
1145/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1146impl std::ops::Drop for PuppetSetEmbeddedViewPropertiesResponder {
1147    fn drop(&mut self) {
1148        self.control_handle.shutdown();
1149        // Safety: drops once, never accessed again
1150        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1151    }
1152}
1153
1154impl fidl::endpoints::Responder for PuppetSetEmbeddedViewPropertiesResponder {
1155    type ControlHandle = PuppetControlHandle;
1156
1157    fn control_handle(&self) -> &PuppetControlHandle {
1158        &self.control_handle
1159    }
1160
1161    fn drop_without_shutdown(mut self) {
1162        // Safety: drops once, never accessed again due to mem::forget
1163        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1164        // Prevent Drop from running (which would shut down the channel)
1165        std::mem::forget(self);
1166    }
1167}
1168
1169impl PuppetSetEmbeddedViewPropertiesResponder {
1170    /// Sends a response to the FIDL transaction.
1171    ///
1172    /// Sets the channel to shutdown if an error occurs.
1173    pub fn send(
1174        self,
1175        mut payload: &PuppetSetEmbeddedViewPropertiesResponse,
1176    ) -> Result<(), fidl::Error> {
1177        let _result = self.send_raw(payload);
1178        if _result.is_err() {
1179            self.control_handle.shutdown();
1180        }
1181        self.drop_without_shutdown();
1182        _result
1183    }
1184
1185    /// Similar to "send" but does not shutdown the channel if an error occurs.
1186    pub fn send_no_shutdown_on_err(
1187        self,
1188        mut payload: &PuppetSetEmbeddedViewPropertiesResponse,
1189    ) -> Result<(), fidl::Error> {
1190        let _result = self.send_raw(payload);
1191        self.drop_without_shutdown();
1192        _result
1193    }
1194
1195    fn send_raw(
1196        &self,
1197        mut payload: &PuppetSetEmbeddedViewPropertiesResponse,
1198    ) -> Result<(), fidl::Error> {
1199        self.control_handle.inner.send::<PuppetSetEmbeddedViewPropertiesResponse>(
1200            payload,
1201            self.tx_id,
1202            0x409a7f3de135c709,
1203            fidl::encoding::DynamicFlags::empty(),
1204        )
1205    }
1206}
1207
1208#[must_use = "FIDL methods require a response to be sent"]
1209#[derive(Debug)]
1210pub struct PuppetDrawImageResponder {
1211    control_handle: std::mem::ManuallyDrop<PuppetControlHandle>,
1212    tx_id: u32,
1213}
1214
1215/// Set the the channel to be shutdown (see [`PuppetControlHandle::shutdown`])
1216/// if the responder is dropped without sending a response, so that the client
1217/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1218impl std::ops::Drop for PuppetDrawImageResponder {
1219    fn drop(&mut self) {
1220        self.control_handle.shutdown();
1221        // Safety: drops once, never accessed again
1222        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1223    }
1224}
1225
1226impl fidl::endpoints::Responder for PuppetDrawImageResponder {
1227    type ControlHandle = PuppetControlHandle;
1228
1229    fn control_handle(&self) -> &PuppetControlHandle {
1230        &self.control_handle
1231    }
1232
1233    fn drop_without_shutdown(mut self) {
1234        // Safety: drops once, never accessed again due to mem::forget
1235        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1236        // Prevent Drop from running (which would shut down the channel)
1237        std::mem::forget(self);
1238    }
1239}
1240
1241impl PuppetDrawImageResponder {
1242    /// Sends a response to the FIDL transaction.
1243    ///
1244    /// Sets the channel to shutdown if an error occurs.
1245    pub fn send(self, mut payload: &PuppetDrawImageResponse) -> Result<(), fidl::Error> {
1246        let _result = self.send_raw(payload);
1247        if _result.is_err() {
1248            self.control_handle.shutdown();
1249        }
1250        self.drop_without_shutdown();
1251        _result
1252    }
1253
1254    /// Similar to "send" but does not shutdown the channel if an error occurs.
1255    pub fn send_no_shutdown_on_err(
1256        self,
1257        mut payload: &PuppetDrawImageResponse,
1258    ) -> Result<(), fidl::Error> {
1259        let _result = self.send_raw(payload);
1260        self.drop_without_shutdown();
1261        _result
1262    }
1263
1264    fn send_raw(&self, mut payload: &PuppetDrawImageResponse) -> Result<(), fidl::Error> {
1265        self.control_handle.inner.send::<PuppetDrawImageResponse>(
1266            payload,
1267            self.tx_id,
1268            0x6d736daa48b835cc,
1269            fidl::encoding::DynamicFlags::empty(),
1270        )
1271    }
1272}
1273
1274#[must_use = "FIDL methods require a response to be sent"]
1275#[derive(Debug)]
1276pub struct PuppetSetImagePropertiesResponder {
1277    control_handle: std::mem::ManuallyDrop<PuppetControlHandle>,
1278    tx_id: u32,
1279}
1280
1281/// Set the the channel to be shutdown (see [`PuppetControlHandle::shutdown`])
1282/// if the responder is dropped without sending a response, so that the client
1283/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1284impl std::ops::Drop for PuppetSetImagePropertiesResponder {
1285    fn drop(&mut self) {
1286        self.control_handle.shutdown();
1287        // Safety: drops once, never accessed again
1288        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1289    }
1290}
1291
1292impl fidl::endpoints::Responder for PuppetSetImagePropertiesResponder {
1293    type ControlHandle = PuppetControlHandle;
1294
1295    fn control_handle(&self) -> &PuppetControlHandle {
1296        &self.control_handle
1297    }
1298
1299    fn drop_without_shutdown(mut self) {
1300        // Safety: drops once, never accessed again due to mem::forget
1301        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1302        // Prevent Drop from running (which would shut down the channel)
1303        std::mem::forget(self);
1304    }
1305}
1306
1307impl PuppetSetImagePropertiesResponder {
1308    /// Sends a response to the FIDL transaction.
1309    ///
1310    /// Sets the channel to shutdown if an error occurs.
1311    pub fn send(self, mut payload: &PuppetSetImagePropertiesResponse) -> Result<(), fidl::Error> {
1312        let _result = self.send_raw(payload);
1313        if _result.is_err() {
1314            self.control_handle.shutdown();
1315        }
1316        self.drop_without_shutdown();
1317        _result
1318    }
1319
1320    /// Similar to "send" but does not shutdown the channel if an error occurs.
1321    pub fn send_no_shutdown_on_err(
1322        self,
1323        mut payload: &PuppetSetImagePropertiesResponse,
1324    ) -> Result<(), fidl::Error> {
1325        let _result = self.send_raw(payload);
1326        self.drop_without_shutdown();
1327        _result
1328    }
1329
1330    fn send_raw(&self, mut payload: &PuppetSetImagePropertiesResponse) -> Result<(), fidl::Error> {
1331        self.control_handle.inner.send::<PuppetSetImagePropertiesResponse>(
1332            payload,
1333            self.tx_id,
1334            0x2683795408d033ff,
1335            fidl::encoding::DynamicFlags::empty(),
1336        )
1337    }
1338}
1339
1340#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
1341pub struct PuppetFactoryMarker;
1342
1343impl fidl::endpoints::ProtocolMarker for PuppetFactoryMarker {
1344    type Proxy = PuppetFactoryProxy;
1345    type RequestStream = PuppetFactoryRequestStream;
1346    #[cfg(target_os = "fuchsia")]
1347    type SynchronousProxy = PuppetFactorySynchronousProxy;
1348
1349    const DEBUG_NAME: &'static str = "fuchsia.ui.test.conformance.PuppetFactory";
1350}
1351impl fidl::endpoints::DiscoverableProtocolMarker for PuppetFactoryMarker {}
1352
1353pub trait PuppetFactoryProxyInterface: Send + Sync {
1354    type CreateResponseFut: std::future::Future<Output = Result<PuppetFactoryCreateResponse, fidl::Error>>
1355        + Send;
1356    fn r#create(&self, payload: PuppetCreationArgs) -> Self::CreateResponseFut;
1357}
1358#[derive(Debug)]
1359#[cfg(target_os = "fuchsia")]
1360pub struct PuppetFactorySynchronousProxy {
1361    client: fidl::client::sync::Client,
1362}
1363
1364#[cfg(target_os = "fuchsia")]
1365impl fidl::endpoints::SynchronousProxy for PuppetFactorySynchronousProxy {
1366    type Proxy = PuppetFactoryProxy;
1367    type Protocol = PuppetFactoryMarker;
1368
1369    fn from_channel(inner: fidl::Channel) -> Self {
1370        Self::new(inner)
1371    }
1372
1373    fn into_channel(self) -> fidl::Channel {
1374        self.client.into_channel()
1375    }
1376
1377    fn as_channel(&self) -> &fidl::Channel {
1378        self.client.as_channel()
1379    }
1380}
1381
1382#[cfg(target_os = "fuchsia")]
1383impl PuppetFactorySynchronousProxy {
1384    pub fn new(channel: fidl::Channel) -> Self {
1385        let protocol_name = <PuppetFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1386        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
1387    }
1388
1389    pub fn into_channel(self) -> fidl::Channel {
1390        self.client.into_channel()
1391    }
1392
1393    /// Waits until an event arrives and returns it. It is safe for other
1394    /// threads to make concurrent requests while waiting for an event.
1395    pub fn wait_for_event(
1396        &self,
1397        deadline: zx::MonotonicInstant,
1398    ) -> Result<PuppetFactoryEvent, fidl::Error> {
1399        PuppetFactoryEvent::decode(self.client.wait_for_event(deadline)?)
1400    }
1401
1402    /// Spawns a puppet instance, which will own a view created using `view_token`, and
1403    /// binds `puppet_server` to it.
1404    pub fn r#create(
1405        &self,
1406        mut payload: PuppetCreationArgs,
1407        ___deadline: zx::MonotonicInstant,
1408    ) -> Result<PuppetFactoryCreateResponse, fidl::Error> {
1409        let _response = self.client.send_query::<PuppetCreationArgs, PuppetFactoryCreateResponse>(
1410            &mut payload,
1411            0x4f90811dc284b595,
1412            fidl::encoding::DynamicFlags::empty(),
1413            ___deadline,
1414        )?;
1415        Ok(_response)
1416    }
1417}
1418
1419#[derive(Debug, Clone)]
1420pub struct PuppetFactoryProxy {
1421    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1422}
1423
1424impl fidl::endpoints::Proxy for PuppetFactoryProxy {
1425    type Protocol = PuppetFactoryMarker;
1426
1427    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1428        Self::new(inner)
1429    }
1430
1431    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1432        self.client.into_channel().map_err(|client| Self { client })
1433    }
1434
1435    fn as_channel(&self) -> &::fidl::AsyncChannel {
1436        self.client.as_channel()
1437    }
1438}
1439
1440impl PuppetFactoryProxy {
1441    /// Create a new Proxy for fuchsia.ui.test.conformance/PuppetFactory.
1442    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1443        let protocol_name = <PuppetFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1444        Self { client: fidl::client::Client::new(channel, protocol_name) }
1445    }
1446
1447    /// Get a Stream of events from the remote end of the protocol.
1448    ///
1449    /// # Panics
1450    ///
1451    /// Panics if the event stream was already taken.
1452    pub fn take_event_stream(&self) -> PuppetFactoryEventStream {
1453        PuppetFactoryEventStream { event_receiver: self.client.take_event_receiver() }
1454    }
1455
1456    /// Spawns a puppet instance, which will own a view created using `view_token`, and
1457    /// binds `puppet_server` to it.
1458    pub fn r#create(
1459        &self,
1460        mut payload: PuppetCreationArgs,
1461    ) -> fidl::client::QueryResponseFut<
1462        PuppetFactoryCreateResponse,
1463        fidl::encoding::DefaultFuchsiaResourceDialect,
1464    > {
1465        PuppetFactoryProxyInterface::r#create(self, payload)
1466    }
1467}
1468
1469impl PuppetFactoryProxyInterface for PuppetFactoryProxy {
1470    type CreateResponseFut = fidl::client::QueryResponseFut<
1471        PuppetFactoryCreateResponse,
1472        fidl::encoding::DefaultFuchsiaResourceDialect,
1473    >;
1474    fn r#create(&self, mut payload: PuppetCreationArgs) -> Self::CreateResponseFut {
1475        fn _decode(
1476            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
1477        ) -> Result<PuppetFactoryCreateResponse, fidl::Error> {
1478            let _response = fidl::client::decode_transaction_body::<
1479                PuppetFactoryCreateResponse,
1480                fidl::encoding::DefaultFuchsiaResourceDialect,
1481                0x4f90811dc284b595,
1482            >(_buf?)?;
1483            Ok(_response)
1484        }
1485        self.client.send_query_and_decode::<PuppetCreationArgs, PuppetFactoryCreateResponse>(
1486            &mut payload,
1487            0x4f90811dc284b595,
1488            fidl::encoding::DynamicFlags::empty(),
1489            _decode,
1490        )
1491    }
1492}
1493
1494pub struct PuppetFactoryEventStream {
1495    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
1496}
1497
1498impl std::marker::Unpin for PuppetFactoryEventStream {}
1499
1500impl futures::stream::FusedStream for PuppetFactoryEventStream {
1501    fn is_terminated(&self) -> bool {
1502        self.event_receiver.is_terminated()
1503    }
1504}
1505
1506impl futures::Stream for PuppetFactoryEventStream {
1507    type Item = Result<PuppetFactoryEvent, fidl::Error>;
1508
1509    fn poll_next(
1510        mut self: std::pin::Pin<&mut Self>,
1511        cx: &mut std::task::Context<'_>,
1512    ) -> std::task::Poll<Option<Self::Item>> {
1513        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
1514            &mut self.event_receiver,
1515            cx
1516        )?) {
1517            Some(buf) => std::task::Poll::Ready(Some(PuppetFactoryEvent::decode(buf))),
1518            None => std::task::Poll::Ready(None),
1519        }
1520    }
1521}
1522
1523#[derive(Debug)]
1524pub enum PuppetFactoryEvent {}
1525
1526impl PuppetFactoryEvent {
1527    /// Decodes a message buffer as a [`PuppetFactoryEvent`].
1528    fn decode(
1529        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
1530    ) -> Result<PuppetFactoryEvent, fidl::Error> {
1531        let (bytes, _handles) = buf.split_mut();
1532        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1533        debug_assert_eq!(tx_header.tx_id, 0);
1534        match tx_header.ordinal {
1535            _ => Err(fidl::Error::UnknownOrdinal {
1536                ordinal: tx_header.ordinal,
1537                protocol_name: <PuppetFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1538            }),
1539        }
1540    }
1541}
1542
1543/// A Stream of incoming requests for fuchsia.ui.test.conformance/PuppetFactory.
1544pub struct PuppetFactoryRequestStream {
1545    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1546    is_terminated: bool,
1547}
1548
1549impl std::marker::Unpin for PuppetFactoryRequestStream {}
1550
1551impl futures::stream::FusedStream for PuppetFactoryRequestStream {
1552    fn is_terminated(&self) -> bool {
1553        self.is_terminated
1554    }
1555}
1556
1557impl fidl::endpoints::RequestStream for PuppetFactoryRequestStream {
1558    type Protocol = PuppetFactoryMarker;
1559    type ControlHandle = PuppetFactoryControlHandle;
1560
1561    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
1562        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
1563    }
1564
1565    fn control_handle(&self) -> Self::ControlHandle {
1566        PuppetFactoryControlHandle { inner: self.inner.clone() }
1567    }
1568
1569    fn into_inner(
1570        self,
1571    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
1572    {
1573        (self.inner, self.is_terminated)
1574    }
1575
1576    fn from_inner(
1577        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1578        is_terminated: bool,
1579    ) -> Self {
1580        Self { inner, is_terminated }
1581    }
1582}
1583
1584impl futures::Stream for PuppetFactoryRequestStream {
1585    type Item = Result<PuppetFactoryRequest, fidl::Error>;
1586
1587    fn poll_next(
1588        mut self: std::pin::Pin<&mut Self>,
1589        cx: &mut std::task::Context<'_>,
1590    ) -> std::task::Poll<Option<Self::Item>> {
1591        let this = &mut *self;
1592        if this.inner.check_shutdown(cx) {
1593            this.is_terminated = true;
1594            return std::task::Poll::Ready(None);
1595        }
1596        if this.is_terminated {
1597            panic!("polled PuppetFactoryRequestStream after completion");
1598        }
1599        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
1600            |bytes, handles| {
1601                match this.inner.channel().read_etc(cx, bytes, handles) {
1602                    std::task::Poll::Ready(Ok(())) => {}
1603                    std::task::Poll::Pending => return std::task::Poll::Pending,
1604                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
1605                        this.is_terminated = true;
1606                        return std::task::Poll::Ready(None);
1607                    }
1608                    std::task::Poll::Ready(Err(e)) => {
1609                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
1610                            e.into(),
1611                        ))))
1612                    }
1613                }
1614
1615                // A message has been received from the channel
1616                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
1617
1618                std::task::Poll::Ready(Some(match header.ordinal {
1619                    0x4f90811dc284b595 => {
1620                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
1621                        let mut req = fidl::new_empty!(
1622                            PuppetCreationArgs,
1623                            fidl::encoding::DefaultFuchsiaResourceDialect
1624                        );
1625                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PuppetCreationArgs>(&header, _body_bytes, handles, &mut req)?;
1626                        let control_handle =
1627                            PuppetFactoryControlHandle { inner: this.inner.clone() };
1628                        Ok(PuppetFactoryRequest::Create {
1629                            payload: req,
1630                            responder: PuppetFactoryCreateResponder {
1631                                control_handle: std::mem::ManuallyDrop::new(control_handle),
1632                                tx_id: header.tx_id,
1633                            },
1634                        })
1635                    }
1636                    _ => Err(fidl::Error::UnknownOrdinal {
1637                        ordinal: header.ordinal,
1638                        protocol_name:
1639                            <PuppetFactoryMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
1640                    }),
1641                }))
1642            },
1643        )
1644    }
1645}
1646
1647/// A helper to spawn a puppet instance, which will own a view created with a specific
1648/// token.
1649#[derive(Debug)]
1650pub enum PuppetFactoryRequest {
1651    /// Spawns a puppet instance, which will own a view created using `view_token`, and
1652    /// binds `puppet_server` to it.
1653    Create { payload: PuppetCreationArgs, responder: PuppetFactoryCreateResponder },
1654}
1655
1656impl PuppetFactoryRequest {
1657    #[allow(irrefutable_let_patterns)]
1658    pub fn into_create(self) -> Option<(PuppetCreationArgs, PuppetFactoryCreateResponder)> {
1659        if let PuppetFactoryRequest::Create { payload, responder } = self {
1660            Some((payload, responder))
1661        } else {
1662            None
1663        }
1664    }
1665
1666    /// Name of the method defined in FIDL
1667    pub fn method_name(&self) -> &'static str {
1668        match *self {
1669            PuppetFactoryRequest::Create { .. } => "create",
1670        }
1671    }
1672}
1673
1674#[derive(Debug, Clone)]
1675pub struct PuppetFactoryControlHandle {
1676    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1677}
1678
1679impl fidl::endpoints::ControlHandle for PuppetFactoryControlHandle {
1680    fn shutdown(&self) {
1681        self.inner.shutdown()
1682    }
1683    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1684        self.inner.shutdown_with_epitaph(status)
1685    }
1686
1687    fn is_closed(&self) -> bool {
1688        self.inner.channel().is_closed()
1689    }
1690    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1691        self.inner.channel().on_closed()
1692    }
1693
1694    #[cfg(target_os = "fuchsia")]
1695    fn signal_peer(
1696        &self,
1697        clear_mask: zx::Signals,
1698        set_mask: zx::Signals,
1699    ) -> Result<(), zx_status::Status> {
1700        use fidl::Peered;
1701        self.inner.channel().signal_peer(clear_mask, set_mask)
1702    }
1703}
1704
1705impl PuppetFactoryControlHandle {}
1706
1707#[must_use = "FIDL methods require a response to be sent"]
1708#[derive(Debug)]
1709pub struct PuppetFactoryCreateResponder {
1710    control_handle: std::mem::ManuallyDrop<PuppetFactoryControlHandle>,
1711    tx_id: u32,
1712}
1713
1714/// Set the the channel to be shutdown (see [`PuppetFactoryControlHandle::shutdown`])
1715/// if the responder is dropped without sending a response, so that the client
1716/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1717impl std::ops::Drop for PuppetFactoryCreateResponder {
1718    fn drop(&mut self) {
1719        self.control_handle.shutdown();
1720        // Safety: drops once, never accessed again
1721        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1722    }
1723}
1724
1725impl fidl::endpoints::Responder for PuppetFactoryCreateResponder {
1726    type ControlHandle = PuppetFactoryControlHandle;
1727
1728    fn control_handle(&self) -> &PuppetFactoryControlHandle {
1729        &self.control_handle
1730    }
1731
1732    fn drop_without_shutdown(mut self) {
1733        // Safety: drops once, never accessed again due to mem::forget
1734        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1735        // Prevent Drop from running (which would shut down the channel)
1736        std::mem::forget(self);
1737    }
1738}
1739
1740impl PuppetFactoryCreateResponder {
1741    /// Sends a response to the FIDL transaction.
1742    ///
1743    /// Sets the channel to shutdown if an error occurs.
1744    pub fn send(self, mut payload: PuppetFactoryCreateResponse) -> Result<(), fidl::Error> {
1745        let _result = self.send_raw(payload);
1746        if _result.is_err() {
1747            self.control_handle.shutdown();
1748        }
1749        self.drop_without_shutdown();
1750        _result
1751    }
1752
1753    /// Similar to "send" but does not shutdown the channel if an error occurs.
1754    pub fn send_no_shutdown_on_err(
1755        self,
1756        mut payload: PuppetFactoryCreateResponse,
1757    ) -> Result<(), fidl::Error> {
1758        let _result = self.send_raw(payload);
1759        self.drop_without_shutdown();
1760        _result
1761    }
1762
1763    fn send_raw(&self, mut payload: PuppetFactoryCreateResponse) -> Result<(), fidl::Error> {
1764        self.control_handle.inner.send::<PuppetFactoryCreateResponse>(
1765            &mut payload,
1766            self.tx_id,
1767            0x4f90811dc284b595,
1768            fidl::encoding::DynamicFlags::empty(),
1769        )
1770    }
1771}
1772
1773mod internal {
1774    use super::*;
1775    unsafe impl fidl::encoding::TypeMarker for Color {
1776        type Owned = Self;
1777
1778        #[inline(always)]
1779        fn inline_align(_context: fidl::encoding::Context) -> usize {
1780            std::mem::align_of::<u32>()
1781        }
1782
1783        #[inline(always)]
1784        fn inline_size(_context: fidl::encoding::Context) -> usize {
1785            std::mem::size_of::<u32>()
1786        }
1787
1788        #[inline(always)]
1789        fn encode_is_copy() -> bool {
1790            false
1791        }
1792
1793        #[inline(always)]
1794        fn decode_is_copy() -> bool {
1795            false
1796        }
1797    }
1798
1799    impl fidl::encoding::ValueTypeMarker for Color {
1800        type Borrowed<'a> = Self;
1801        #[inline(always)]
1802        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1803            *value
1804        }
1805    }
1806
1807    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Color {
1808        #[inline]
1809        unsafe fn encode(
1810            self,
1811            encoder: &mut fidl::encoding::Encoder<'_, D>,
1812            offset: usize,
1813            _depth: fidl::encoding::Depth,
1814        ) -> fidl::Result<()> {
1815            encoder.debug_check_bounds::<Self>(offset);
1816            encoder.write_num(self.into_primitive(), offset);
1817            Ok(())
1818        }
1819    }
1820
1821    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Color {
1822        #[inline(always)]
1823        fn new_empty() -> Self {
1824            Self::unknown()
1825        }
1826
1827        #[inline]
1828        unsafe fn decode(
1829            &mut self,
1830            decoder: &mut fidl::encoding::Decoder<'_, D>,
1831            offset: usize,
1832            _depth: fidl::encoding::Depth,
1833        ) -> fidl::Result<()> {
1834            decoder.debug_check_bounds::<Self>(offset);
1835            let prim = decoder.read_num::<u32>(offset);
1836
1837            *self = Self::from_primitive_allow_unknown(prim);
1838            Ok(())
1839        }
1840    }
1841    unsafe impl fidl::encoding::TypeMarker for Result_ {
1842        type Owned = Self;
1843
1844        #[inline(always)]
1845        fn inline_align(_context: fidl::encoding::Context) -> usize {
1846            std::mem::align_of::<u32>()
1847        }
1848
1849        #[inline(always)]
1850        fn inline_size(_context: fidl::encoding::Context) -> usize {
1851            std::mem::size_of::<u32>()
1852        }
1853
1854        #[inline(always)]
1855        fn encode_is_copy() -> bool {
1856            false
1857        }
1858
1859        #[inline(always)]
1860        fn decode_is_copy() -> bool {
1861            false
1862        }
1863    }
1864
1865    impl fidl::encoding::ValueTypeMarker for Result_ {
1866        type Borrowed<'a> = Self;
1867        #[inline(always)]
1868        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1869            *value
1870        }
1871    }
1872
1873    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Result_ {
1874        #[inline]
1875        unsafe fn encode(
1876            self,
1877            encoder: &mut fidl::encoding::Encoder<'_, D>,
1878            offset: usize,
1879            _depth: fidl::encoding::Depth,
1880        ) -> fidl::Result<()> {
1881            encoder.debug_check_bounds::<Self>(offset);
1882            encoder.write_num(self.into_primitive(), offset);
1883            Ok(())
1884        }
1885    }
1886
1887    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Result_ {
1888        #[inline(always)]
1889        fn new_empty() -> Self {
1890            Self::unknown()
1891        }
1892
1893        #[inline]
1894        unsafe fn decode(
1895            &mut self,
1896            decoder: &mut fidl::encoding::Decoder<'_, D>,
1897            offset: usize,
1898            _depth: fidl::encoding::Depth,
1899        ) -> fidl::Result<()> {
1900            decoder.debug_check_bounds::<Self>(offset);
1901            let prim = decoder.read_num::<u32>(offset);
1902
1903            *self = Self::from_primitive_allow_unknown(prim);
1904            Ok(())
1905        }
1906    }
1907
1908    impl ContentBounds {
1909        #[inline(always)]
1910        fn max_ordinal_present(&self) -> u64 {
1911            if let Some(_) = self.origin {
1912                return 2;
1913            }
1914            if let Some(_) = self.size {
1915                return 1;
1916            }
1917            0
1918        }
1919    }
1920
1921    impl fidl::encoding::ValueTypeMarker for ContentBounds {
1922        type Borrowed<'a> = &'a Self;
1923        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1924            value
1925        }
1926    }
1927
1928    unsafe impl fidl::encoding::TypeMarker for ContentBounds {
1929        type Owned = Self;
1930
1931        #[inline(always)]
1932        fn inline_align(_context: fidl::encoding::Context) -> usize {
1933            8
1934        }
1935
1936        #[inline(always)]
1937        fn inline_size(_context: fidl::encoding::Context) -> usize {
1938            16
1939        }
1940    }
1941
1942    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ContentBounds, D>
1943        for &ContentBounds
1944    {
1945        unsafe fn encode(
1946            self,
1947            encoder: &mut fidl::encoding::Encoder<'_, D>,
1948            offset: usize,
1949            mut depth: fidl::encoding::Depth,
1950        ) -> fidl::Result<()> {
1951            encoder.debug_check_bounds::<ContentBounds>(offset);
1952            // Vector header
1953            let max_ordinal: u64 = self.max_ordinal_present();
1954            encoder.write_num(max_ordinal, offset);
1955            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1956            // Calling encoder.out_of_line_offset(0) is not allowed.
1957            if max_ordinal == 0 {
1958                return Ok(());
1959            }
1960            depth.increment()?;
1961            let envelope_size = 8;
1962            let bytes_len = max_ordinal as usize * envelope_size;
1963            #[allow(unused_variables)]
1964            let offset = encoder.out_of_line_offset(bytes_len);
1965            let mut _prev_end_offset: usize = 0;
1966            if 1 > max_ordinal {
1967                return Ok(());
1968            }
1969
1970            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1971            // are envelope_size bytes.
1972            let cur_offset: usize = (1 - 1) * envelope_size;
1973
1974            // Zero reserved fields.
1975            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1976
1977            // Safety:
1978            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1979            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1980            //   envelope_size bytes, there is always sufficient room.
1981            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math::SizeU, D>(
1982                self.size
1983                    .as_ref()
1984                    .map(<fidl_fuchsia_math::SizeU as fidl::encoding::ValueTypeMarker>::borrow),
1985                encoder,
1986                offset + cur_offset,
1987                depth,
1988            )?;
1989
1990            _prev_end_offset = cur_offset + envelope_size;
1991            if 2 > max_ordinal {
1992                return Ok(());
1993            }
1994
1995            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1996            // are envelope_size bytes.
1997            let cur_offset: usize = (2 - 1) * envelope_size;
1998
1999            // Zero reserved fields.
2000            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2001
2002            // Safety:
2003            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2004            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2005            //   envelope_size bytes, there is always sufficient room.
2006            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_math::Vec_, D>(
2007                self.origin
2008                    .as_ref()
2009                    .map(<fidl_fuchsia_math::Vec_ as fidl::encoding::ValueTypeMarker>::borrow),
2010                encoder,
2011                offset + cur_offset,
2012                depth,
2013            )?;
2014
2015            _prev_end_offset = cur_offset + envelope_size;
2016
2017            Ok(())
2018        }
2019    }
2020
2021    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ContentBounds {
2022        #[inline(always)]
2023        fn new_empty() -> Self {
2024            Self::default()
2025        }
2026
2027        unsafe fn decode(
2028            &mut self,
2029            decoder: &mut fidl::encoding::Decoder<'_, D>,
2030            offset: usize,
2031            mut depth: fidl::encoding::Depth,
2032        ) -> fidl::Result<()> {
2033            decoder.debug_check_bounds::<Self>(offset);
2034            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2035                None => return Err(fidl::Error::NotNullable),
2036                Some(len) => len,
2037            };
2038            // Calling decoder.out_of_line_offset(0) is not allowed.
2039            if len == 0 {
2040                return Ok(());
2041            };
2042            depth.increment()?;
2043            let envelope_size = 8;
2044            let bytes_len = len * envelope_size;
2045            let offset = decoder.out_of_line_offset(bytes_len)?;
2046            // Decode the envelope for each type.
2047            let mut _next_ordinal_to_read = 0;
2048            let mut next_offset = offset;
2049            let end_offset = offset + bytes_len;
2050            _next_ordinal_to_read += 1;
2051            if next_offset >= end_offset {
2052                return Ok(());
2053            }
2054
2055            // Decode unknown envelopes for gaps in ordinals.
2056            while _next_ordinal_to_read < 1 {
2057                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2058                _next_ordinal_to_read += 1;
2059                next_offset += envelope_size;
2060            }
2061
2062            let next_out_of_line = decoder.next_out_of_line();
2063            let handles_before = decoder.remaining_handles();
2064            if let Some((inlined, num_bytes, num_handles)) =
2065                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2066            {
2067                let member_inline_size =
2068                    <fidl_fuchsia_math::SizeU as fidl::encoding::TypeMarker>::inline_size(
2069                        decoder.context,
2070                    );
2071                if inlined != (member_inline_size <= 4) {
2072                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2073                }
2074                let inner_offset;
2075                let mut inner_depth = depth.clone();
2076                if inlined {
2077                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2078                    inner_offset = next_offset;
2079                } else {
2080                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2081                    inner_depth.increment()?;
2082                }
2083                let val_ref =
2084                    self.size.get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math::SizeU, D));
2085                fidl::decode!(
2086                    fidl_fuchsia_math::SizeU,
2087                    D,
2088                    val_ref,
2089                    decoder,
2090                    inner_offset,
2091                    inner_depth
2092                )?;
2093                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2094                {
2095                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2096                }
2097                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2098                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2099                }
2100            }
2101
2102            next_offset += envelope_size;
2103            _next_ordinal_to_read += 1;
2104            if next_offset >= end_offset {
2105                return Ok(());
2106            }
2107
2108            // Decode unknown envelopes for gaps in ordinals.
2109            while _next_ordinal_to_read < 2 {
2110                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2111                _next_ordinal_to_read += 1;
2112                next_offset += envelope_size;
2113            }
2114
2115            let next_out_of_line = decoder.next_out_of_line();
2116            let handles_before = decoder.remaining_handles();
2117            if let Some((inlined, num_bytes, num_handles)) =
2118                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2119            {
2120                let member_inline_size =
2121                    <fidl_fuchsia_math::Vec_ as fidl::encoding::TypeMarker>::inline_size(
2122                        decoder.context,
2123                    );
2124                if inlined != (member_inline_size <= 4) {
2125                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2126                }
2127                let inner_offset;
2128                let mut inner_depth = depth.clone();
2129                if inlined {
2130                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2131                    inner_offset = next_offset;
2132                } else {
2133                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2134                    inner_depth.increment()?;
2135                }
2136                let val_ref =
2137                    self.origin.get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_math::Vec_, D));
2138                fidl::decode!(
2139                    fidl_fuchsia_math::Vec_,
2140                    D,
2141                    val_ref,
2142                    decoder,
2143                    inner_offset,
2144                    inner_depth
2145                )?;
2146                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2147                {
2148                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2149                }
2150                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2151                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2152                }
2153            }
2154
2155            next_offset += envelope_size;
2156
2157            // Decode the remaining unknown envelopes.
2158            while next_offset < end_offset {
2159                _next_ordinal_to_read += 1;
2160                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2161                next_offset += envelope_size;
2162            }
2163
2164            Ok(())
2165        }
2166    }
2167
2168    impl EmbeddedViewProperties {
2169        #[inline(always)]
2170        fn max_ordinal_present(&self) -> u64 {
2171            if let Some(_) = self.bounds {
2172                return 1;
2173            }
2174            0
2175        }
2176    }
2177
2178    impl fidl::encoding::ValueTypeMarker for EmbeddedViewProperties {
2179        type Borrowed<'a> = &'a Self;
2180        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2181            value
2182        }
2183    }
2184
2185    unsafe impl fidl::encoding::TypeMarker for EmbeddedViewProperties {
2186        type Owned = Self;
2187
2188        #[inline(always)]
2189        fn inline_align(_context: fidl::encoding::Context) -> usize {
2190            8
2191        }
2192
2193        #[inline(always)]
2194        fn inline_size(_context: fidl::encoding::Context) -> usize {
2195            16
2196        }
2197    }
2198
2199    unsafe impl<D: fidl::encoding::ResourceDialect>
2200        fidl::encoding::Encode<EmbeddedViewProperties, D> for &EmbeddedViewProperties
2201    {
2202        unsafe fn encode(
2203            self,
2204            encoder: &mut fidl::encoding::Encoder<'_, D>,
2205            offset: usize,
2206            mut depth: fidl::encoding::Depth,
2207        ) -> fidl::Result<()> {
2208            encoder.debug_check_bounds::<EmbeddedViewProperties>(offset);
2209            // Vector header
2210            let max_ordinal: u64 = self.max_ordinal_present();
2211            encoder.write_num(max_ordinal, offset);
2212            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2213            // Calling encoder.out_of_line_offset(0) is not allowed.
2214            if max_ordinal == 0 {
2215                return Ok(());
2216            }
2217            depth.increment()?;
2218            let envelope_size = 8;
2219            let bytes_len = max_ordinal as usize * envelope_size;
2220            #[allow(unused_variables)]
2221            let offset = encoder.out_of_line_offset(bytes_len);
2222            let mut _prev_end_offset: usize = 0;
2223            if 1 > max_ordinal {
2224                return Ok(());
2225            }
2226
2227            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2228            // are envelope_size bytes.
2229            let cur_offset: usize = (1 - 1) * envelope_size;
2230
2231            // Zero reserved fields.
2232            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2233
2234            // Safety:
2235            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2236            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2237            //   envelope_size bytes, there is always sufficient room.
2238            fidl::encoding::encode_in_envelope_optional::<ContentBounds, D>(
2239                self.bounds
2240                    .as_ref()
2241                    .map(<ContentBounds as fidl::encoding::ValueTypeMarker>::borrow),
2242                encoder,
2243                offset + cur_offset,
2244                depth,
2245            )?;
2246
2247            _prev_end_offset = cur_offset + envelope_size;
2248
2249            Ok(())
2250        }
2251    }
2252
2253    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2254        for EmbeddedViewProperties
2255    {
2256        #[inline(always)]
2257        fn new_empty() -> Self {
2258            Self::default()
2259        }
2260
2261        unsafe fn decode(
2262            &mut self,
2263            decoder: &mut fidl::encoding::Decoder<'_, D>,
2264            offset: usize,
2265            mut depth: fidl::encoding::Depth,
2266        ) -> fidl::Result<()> {
2267            decoder.debug_check_bounds::<Self>(offset);
2268            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2269                None => return Err(fidl::Error::NotNullable),
2270                Some(len) => len,
2271            };
2272            // Calling decoder.out_of_line_offset(0) is not allowed.
2273            if len == 0 {
2274                return Ok(());
2275            };
2276            depth.increment()?;
2277            let envelope_size = 8;
2278            let bytes_len = len * envelope_size;
2279            let offset = decoder.out_of_line_offset(bytes_len)?;
2280            // Decode the envelope for each type.
2281            let mut _next_ordinal_to_read = 0;
2282            let mut next_offset = offset;
2283            let end_offset = offset + bytes_len;
2284            _next_ordinal_to_read += 1;
2285            if next_offset >= end_offset {
2286                return Ok(());
2287            }
2288
2289            // Decode unknown envelopes for gaps in ordinals.
2290            while _next_ordinal_to_read < 1 {
2291                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2292                _next_ordinal_to_read += 1;
2293                next_offset += envelope_size;
2294            }
2295
2296            let next_out_of_line = decoder.next_out_of_line();
2297            let handles_before = decoder.remaining_handles();
2298            if let Some((inlined, num_bytes, num_handles)) =
2299                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2300            {
2301                let member_inline_size =
2302                    <ContentBounds as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2303                if inlined != (member_inline_size <= 4) {
2304                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2305                }
2306                let inner_offset;
2307                let mut inner_depth = depth.clone();
2308                if inlined {
2309                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2310                    inner_offset = next_offset;
2311                } else {
2312                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2313                    inner_depth.increment()?;
2314                }
2315                let val_ref = self.bounds.get_or_insert_with(|| fidl::new_empty!(ContentBounds, D));
2316                fidl::decode!(ContentBounds, D, val_ref, decoder, inner_offset, inner_depth)?;
2317                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2318                {
2319                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2320                }
2321                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2322                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2323                }
2324            }
2325
2326            next_offset += envelope_size;
2327
2328            // Decode the remaining unknown envelopes.
2329            while next_offset < end_offset {
2330                _next_ordinal_to_read += 1;
2331                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2332                next_offset += envelope_size;
2333            }
2334
2335            Ok(())
2336        }
2337    }
2338
2339    impl FilledRect {
2340        #[inline(always)]
2341        fn max_ordinal_present(&self) -> u64 {
2342            if let Some(_) = self.bounds {
2343                return 2;
2344            }
2345            if let Some(_) = self.color {
2346                return 1;
2347            }
2348            0
2349        }
2350    }
2351
2352    impl fidl::encoding::ValueTypeMarker for FilledRect {
2353        type Borrowed<'a> = &'a Self;
2354        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2355            value
2356        }
2357    }
2358
2359    unsafe impl fidl::encoding::TypeMarker for FilledRect {
2360        type Owned = Self;
2361
2362        #[inline(always)]
2363        fn inline_align(_context: fidl::encoding::Context) -> usize {
2364            8
2365        }
2366
2367        #[inline(always)]
2368        fn inline_size(_context: fidl::encoding::Context) -> usize {
2369            16
2370        }
2371    }
2372
2373    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FilledRect, D>
2374        for &FilledRect
2375    {
2376        unsafe fn encode(
2377            self,
2378            encoder: &mut fidl::encoding::Encoder<'_, D>,
2379            offset: usize,
2380            mut depth: fidl::encoding::Depth,
2381        ) -> fidl::Result<()> {
2382            encoder.debug_check_bounds::<FilledRect>(offset);
2383            // Vector header
2384            let max_ordinal: u64 = self.max_ordinal_present();
2385            encoder.write_num(max_ordinal, offset);
2386            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2387            // Calling encoder.out_of_line_offset(0) is not allowed.
2388            if max_ordinal == 0 {
2389                return Ok(());
2390            }
2391            depth.increment()?;
2392            let envelope_size = 8;
2393            let bytes_len = max_ordinal as usize * envelope_size;
2394            #[allow(unused_variables)]
2395            let offset = encoder.out_of_line_offset(bytes_len);
2396            let mut _prev_end_offset: usize = 0;
2397            if 1 > max_ordinal {
2398                return Ok(());
2399            }
2400
2401            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2402            // are envelope_size bytes.
2403            let cur_offset: usize = (1 - 1) * envelope_size;
2404
2405            // Zero reserved fields.
2406            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2407
2408            // Safety:
2409            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2410            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2411            //   envelope_size bytes, there is always sufficient room.
2412            fidl::encoding::encode_in_envelope_optional::<Color, D>(
2413                self.color.as_ref().map(<Color as fidl::encoding::ValueTypeMarker>::borrow),
2414                encoder,
2415                offset + cur_offset,
2416                depth,
2417            )?;
2418
2419            _prev_end_offset = cur_offset + envelope_size;
2420            if 2 > max_ordinal {
2421                return Ok(());
2422            }
2423
2424            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2425            // are envelope_size bytes.
2426            let cur_offset: usize = (2 - 1) * envelope_size;
2427
2428            // Zero reserved fields.
2429            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2430
2431            // Safety:
2432            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2433            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2434            //   envelope_size bytes, there is always sufficient room.
2435            fidl::encoding::encode_in_envelope_optional::<ContentBounds, D>(
2436                self.bounds
2437                    .as_ref()
2438                    .map(<ContentBounds as fidl::encoding::ValueTypeMarker>::borrow),
2439                encoder,
2440                offset + cur_offset,
2441                depth,
2442            )?;
2443
2444            _prev_end_offset = cur_offset + envelope_size;
2445
2446            Ok(())
2447        }
2448    }
2449
2450    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FilledRect {
2451        #[inline(always)]
2452        fn new_empty() -> Self {
2453            Self::default()
2454        }
2455
2456        unsafe fn decode(
2457            &mut self,
2458            decoder: &mut fidl::encoding::Decoder<'_, D>,
2459            offset: usize,
2460            mut depth: fidl::encoding::Depth,
2461        ) -> fidl::Result<()> {
2462            decoder.debug_check_bounds::<Self>(offset);
2463            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2464                None => return Err(fidl::Error::NotNullable),
2465                Some(len) => len,
2466            };
2467            // Calling decoder.out_of_line_offset(0) is not allowed.
2468            if len == 0 {
2469                return Ok(());
2470            };
2471            depth.increment()?;
2472            let envelope_size = 8;
2473            let bytes_len = len * envelope_size;
2474            let offset = decoder.out_of_line_offset(bytes_len)?;
2475            // Decode the envelope for each type.
2476            let mut _next_ordinal_to_read = 0;
2477            let mut next_offset = offset;
2478            let end_offset = offset + bytes_len;
2479            _next_ordinal_to_read += 1;
2480            if next_offset >= end_offset {
2481                return Ok(());
2482            }
2483
2484            // Decode unknown envelopes for gaps in ordinals.
2485            while _next_ordinal_to_read < 1 {
2486                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2487                _next_ordinal_to_read += 1;
2488                next_offset += envelope_size;
2489            }
2490
2491            let next_out_of_line = decoder.next_out_of_line();
2492            let handles_before = decoder.remaining_handles();
2493            if let Some((inlined, num_bytes, num_handles)) =
2494                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2495            {
2496                let member_inline_size =
2497                    <Color as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2498                if inlined != (member_inline_size <= 4) {
2499                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2500                }
2501                let inner_offset;
2502                let mut inner_depth = depth.clone();
2503                if inlined {
2504                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2505                    inner_offset = next_offset;
2506                } else {
2507                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2508                    inner_depth.increment()?;
2509                }
2510                let val_ref = self.color.get_or_insert_with(|| fidl::new_empty!(Color, D));
2511                fidl::decode!(Color, D, val_ref, decoder, inner_offset, inner_depth)?;
2512                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2513                {
2514                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2515                }
2516                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2517                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2518                }
2519            }
2520
2521            next_offset += envelope_size;
2522            _next_ordinal_to_read += 1;
2523            if next_offset >= end_offset {
2524                return Ok(());
2525            }
2526
2527            // Decode unknown envelopes for gaps in ordinals.
2528            while _next_ordinal_to_read < 2 {
2529                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2530                _next_ordinal_to_read += 1;
2531                next_offset += envelope_size;
2532            }
2533
2534            let next_out_of_line = decoder.next_out_of_line();
2535            let handles_before = decoder.remaining_handles();
2536            if let Some((inlined, num_bytes, num_handles)) =
2537                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2538            {
2539                let member_inline_size =
2540                    <ContentBounds as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2541                if inlined != (member_inline_size <= 4) {
2542                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2543                }
2544                let inner_offset;
2545                let mut inner_depth = depth.clone();
2546                if inlined {
2547                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2548                    inner_offset = next_offset;
2549                } else {
2550                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2551                    inner_depth.increment()?;
2552                }
2553                let val_ref = self.bounds.get_or_insert_with(|| fidl::new_empty!(ContentBounds, D));
2554                fidl::decode!(ContentBounds, D, val_ref, decoder, inner_offset, inner_depth)?;
2555                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2556                {
2557                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2558                }
2559                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2560                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2561                }
2562            }
2563
2564            next_offset += envelope_size;
2565
2566            // Decode the remaining unknown envelopes.
2567            while next_offset < end_offset {
2568                _next_ordinal_to_read += 1;
2569                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2570                next_offset += envelope_size;
2571            }
2572
2573            Ok(())
2574        }
2575    }
2576
2577    impl ImageProperties {
2578        #[inline(always)]
2579        fn max_ordinal_present(&self) -> u64 {
2580            if let Some(_) = self.filled_rects {
2581                return 2;
2582            }
2583            if let Some(_) = self.bounds {
2584                return 1;
2585            }
2586            0
2587        }
2588    }
2589
2590    impl fidl::encoding::ValueTypeMarker for ImageProperties {
2591        type Borrowed<'a> = &'a Self;
2592        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2593            value
2594        }
2595    }
2596
2597    unsafe impl fidl::encoding::TypeMarker for ImageProperties {
2598        type Owned = Self;
2599
2600        #[inline(always)]
2601        fn inline_align(_context: fidl::encoding::Context) -> usize {
2602            8
2603        }
2604
2605        #[inline(always)]
2606        fn inline_size(_context: fidl::encoding::Context) -> usize {
2607            16
2608        }
2609    }
2610
2611    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ImageProperties, D>
2612        for &ImageProperties
2613    {
2614        unsafe fn encode(
2615            self,
2616            encoder: &mut fidl::encoding::Encoder<'_, D>,
2617            offset: usize,
2618            mut depth: fidl::encoding::Depth,
2619        ) -> fidl::Result<()> {
2620            encoder.debug_check_bounds::<ImageProperties>(offset);
2621            // Vector header
2622            let max_ordinal: u64 = self.max_ordinal_present();
2623            encoder.write_num(max_ordinal, offset);
2624            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2625            // Calling encoder.out_of_line_offset(0) is not allowed.
2626            if max_ordinal == 0 {
2627                return Ok(());
2628            }
2629            depth.increment()?;
2630            let envelope_size = 8;
2631            let bytes_len = max_ordinal as usize * envelope_size;
2632            #[allow(unused_variables)]
2633            let offset = encoder.out_of_line_offset(bytes_len);
2634            let mut _prev_end_offset: usize = 0;
2635            if 1 > max_ordinal {
2636                return Ok(());
2637            }
2638
2639            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2640            // are envelope_size bytes.
2641            let cur_offset: usize = (1 - 1) * envelope_size;
2642
2643            // Zero reserved fields.
2644            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2645
2646            // Safety:
2647            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2648            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2649            //   envelope_size bytes, there is always sufficient room.
2650            fidl::encoding::encode_in_envelope_optional::<ContentBounds, D>(
2651                self.bounds
2652                    .as_ref()
2653                    .map(<ContentBounds as fidl::encoding::ValueTypeMarker>::borrow),
2654                encoder,
2655                offset + cur_offset,
2656                depth,
2657            )?;
2658
2659            _prev_end_offset = cur_offset + envelope_size;
2660            if 2 > max_ordinal {
2661                return Ok(());
2662            }
2663
2664            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2665            // are envelope_size bytes.
2666            let cur_offset: usize = (2 - 1) * envelope_size;
2667
2668            // Zero reserved fields.
2669            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2670
2671            // Safety:
2672            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2673            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2674            //   envelope_size bytes, there is always sufficient room.
2675            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<FilledRect, 1024>, D>(
2676            self.filled_rects.as_ref().map(<fidl::encoding::Vector<FilledRect, 1024> as fidl::encoding::ValueTypeMarker>::borrow),
2677            encoder, offset + cur_offset, depth
2678        )?;
2679
2680            _prev_end_offset = cur_offset + envelope_size;
2681
2682            Ok(())
2683        }
2684    }
2685
2686    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ImageProperties {
2687        #[inline(always)]
2688        fn new_empty() -> Self {
2689            Self::default()
2690        }
2691
2692        unsafe fn decode(
2693            &mut self,
2694            decoder: &mut fidl::encoding::Decoder<'_, D>,
2695            offset: usize,
2696            mut depth: fidl::encoding::Depth,
2697        ) -> fidl::Result<()> {
2698            decoder.debug_check_bounds::<Self>(offset);
2699            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2700                None => return Err(fidl::Error::NotNullable),
2701                Some(len) => len,
2702            };
2703            // Calling decoder.out_of_line_offset(0) is not allowed.
2704            if len == 0 {
2705                return Ok(());
2706            };
2707            depth.increment()?;
2708            let envelope_size = 8;
2709            let bytes_len = len * envelope_size;
2710            let offset = decoder.out_of_line_offset(bytes_len)?;
2711            // Decode the envelope for each type.
2712            let mut _next_ordinal_to_read = 0;
2713            let mut next_offset = offset;
2714            let end_offset = offset + bytes_len;
2715            _next_ordinal_to_read += 1;
2716            if next_offset >= end_offset {
2717                return Ok(());
2718            }
2719
2720            // Decode unknown envelopes for gaps in ordinals.
2721            while _next_ordinal_to_read < 1 {
2722                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2723                _next_ordinal_to_read += 1;
2724                next_offset += envelope_size;
2725            }
2726
2727            let next_out_of_line = decoder.next_out_of_line();
2728            let handles_before = decoder.remaining_handles();
2729            if let Some((inlined, num_bytes, num_handles)) =
2730                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2731            {
2732                let member_inline_size =
2733                    <ContentBounds as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2734                if inlined != (member_inline_size <= 4) {
2735                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2736                }
2737                let inner_offset;
2738                let mut inner_depth = depth.clone();
2739                if inlined {
2740                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2741                    inner_offset = next_offset;
2742                } else {
2743                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2744                    inner_depth.increment()?;
2745                }
2746                let val_ref = self.bounds.get_or_insert_with(|| fidl::new_empty!(ContentBounds, D));
2747                fidl::decode!(ContentBounds, D, val_ref, decoder, inner_offset, inner_depth)?;
2748                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2749                {
2750                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2751                }
2752                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2753                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2754                }
2755            }
2756
2757            next_offset += envelope_size;
2758            _next_ordinal_to_read += 1;
2759            if next_offset >= end_offset {
2760                return Ok(());
2761            }
2762
2763            // Decode unknown envelopes for gaps in ordinals.
2764            while _next_ordinal_to_read < 2 {
2765                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2766                _next_ordinal_to_read += 1;
2767                next_offset += envelope_size;
2768            }
2769
2770            let next_out_of_line = decoder.next_out_of_line();
2771            let handles_before = decoder.remaining_handles();
2772            if let Some((inlined, num_bytes, num_handles)) =
2773                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2774            {
2775                let member_inline_size = <fidl::encoding::Vector<FilledRect, 1024> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2776                if inlined != (member_inline_size <= 4) {
2777                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2778                }
2779                let inner_offset;
2780                let mut inner_depth = depth.clone();
2781                if inlined {
2782                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2783                    inner_offset = next_offset;
2784                } else {
2785                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2786                    inner_depth.increment()?;
2787                }
2788                let val_ref = self.filled_rects.get_or_insert_with(
2789                    || fidl::new_empty!(fidl::encoding::Vector<FilledRect, 1024>, D),
2790                );
2791                fidl::decode!(fidl::encoding::Vector<FilledRect, 1024>, D, val_ref, decoder, inner_offset, inner_depth)?;
2792                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2793                {
2794                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2795                }
2796                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2797                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2798                }
2799            }
2800
2801            next_offset += envelope_size;
2802
2803            // Decode the remaining unknown envelopes.
2804            while next_offset < end_offset {
2805                _next_ordinal_to_read += 1;
2806                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2807                next_offset += envelope_size;
2808            }
2809
2810            Ok(())
2811        }
2812    }
2813
2814    impl PuppetCreationArgs {
2815        #[inline(always)]
2816        fn max_ordinal_present(&self) -> u64 {
2817            if let Some(_) = self.focuser {
2818                return 9;
2819            }
2820            if let Some(_) = self.device_pixel_ratio {
2821                return 8;
2822            }
2823            if let Some(_) = self.keyboard_client {
2824                return 7;
2825            }
2826            if let Some(_) = self.flatland_client {
2827                return 6;
2828            }
2829            if let Some(_) = self.keyboard_listener {
2830                return 5;
2831            }
2832            if let Some(_) = self.mouse_listener {
2833                return 4;
2834            }
2835            if let Some(_) = self.touch_listener {
2836                return 3;
2837            }
2838            if let Some(_) = self.view_token {
2839                return 2;
2840            }
2841            if let Some(_) = self.server_end {
2842                return 1;
2843            }
2844            0
2845        }
2846    }
2847
2848    impl fidl::encoding::ResourceTypeMarker for PuppetCreationArgs {
2849        type Borrowed<'a> = &'a mut Self;
2850        fn take_or_borrow<'a>(
2851            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
2852        ) -> Self::Borrowed<'a> {
2853            value
2854        }
2855    }
2856
2857    unsafe impl fidl::encoding::TypeMarker for PuppetCreationArgs {
2858        type Owned = Self;
2859
2860        #[inline(always)]
2861        fn inline_align(_context: fidl::encoding::Context) -> usize {
2862            8
2863        }
2864
2865        #[inline(always)]
2866        fn inline_size(_context: fidl::encoding::Context) -> usize {
2867            16
2868        }
2869    }
2870
2871    unsafe impl
2872        fidl::encoding::Encode<PuppetCreationArgs, fidl::encoding::DefaultFuchsiaResourceDialect>
2873        for &mut PuppetCreationArgs
2874    {
2875        unsafe fn encode(
2876            self,
2877            encoder: &mut fidl::encoding::Encoder<
2878                '_,
2879                fidl::encoding::DefaultFuchsiaResourceDialect,
2880            >,
2881            offset: usize,
2882            mut depth: fidl::encoding::Depth,
2883        ) -> fidl::Result<()> {
2884            encoder.debug_check_bounds::<PuppetCreationArgs>(offset);
2885            // Vector header
2886            let max_ordinal: u64 = self.max_ordinal_present();
2887            encoder.write_num(max_ordinal, offset);
2888            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2889            // Calling encoder.out_of_line_offset(0) is not allowed.
2890            if max_ordinal == 0 {
2891                return Ok(());
2892            }
2893            depth.increment()?;
2894            let envelope_size = 8;
2895            let bytes_len = max_ordinal as usize * envelope_size;
2896            #[allow(unused_variables)]
2897            let offset = encoder.out_of_line_offset(bytes_len);
2898            let mut _prev_end_offset: usize = 0;
2899            if 1 > max_ordinal {
2900                return Ok(());
2901            }
2902
2903            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2904            // are envelope_size bytes.
2905            let cur_offset: usize = (1 - 1) * envelope_size;
2906
2907            // Zero reserved fields.
2908            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2909
2910            // Safety:
2911            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2912            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2913            //   envelope_size bytes, there is always sufficient room.
2914            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PuppetMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
2915            self.server_end.as_mut().map(<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PuppetMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
2916            encoder, offset + cur_offset, depth
2917        )?;
2918
2919            _prev_end_offset = cur_offset + envelope_size;
2920            if 2 > max_ordinal {
2921                return Ok(());
2922            }
2923
2924            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2925            // are envelope_size bytes.
2926            let cur_offset: usize = (2 - 1) * envelope_size;
2927
2928            // Zero reserved fields.
2929            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2930
2931            // Safety:
2932            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2933            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2934            //   envelope_size bytes, there is always sufficient room.
2935            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_ui_views::ViewCreationToken, fidl::encoding::DefaultFuchsiaResourceDialect>(
2936            self.view_token.as_mut().map(<fidl_fuchsia_ui_views::ViewCreationToken as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
2937            encoder, offset + cur_offset, depth
2938        )?;
2939
2940            _prev_end_offset = cur_offset + envelope_size;
2941            if 3 > max_ordinal {
2942                return Ok(());
2943            }
2944
2945            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2946            // are envelope_size bytes.
2947            let cur_offset: usize = (3 - 1) * envelope_size;
2948
2949            // Zero reserved fields.
2950            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2951
2952            // Safety:
2953            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2954            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2955            //   envelope_size bytes, there is always sufficient room.
2956            fidl::encoding::encode_in_envelope_optional::<
2957                fidl::encoding::Endpoint<
2958                    fidl::endpoints::ClientEnd<
2959                        fidl_fuchsia_ui_test_input::TouchInputListenerMarker,
2960                    >,
2961                >,
2962                fidl::encoding::DefaultFuchsiaResourceDialect,
2963            >(
2964                self.touch_listener.as_mut().map(
2965                    <fidl::encoding::Endpoint<
2966                        fidl::endpoints::ClientEnd<
2967                            fidl_fuchsia_ui_test_input::TouchInputListenerMarker,
2968                        >,
2969                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
2970                ),
2971                encoder,
2972                offset + cur_offset,
2973                depth,
2974            )?;
2975
2976            _prev_end_offset = cur_offset + envelope_size;
2977            if 4 > max_ordinal {
2978                return Ok(());
2979            }
2980
2981            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2982            // are envelope_size bytes.
2983            let cur_offset: usize = (4 - 1) * envelope_size;
2984
2985            // Zero reserved fields.
2986            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2987
2988            // Safety:
2989            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2990            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2991            //   envelope_size bytes, there is always sufficient room.
2992            fidl::encoding::encode_in_envelope_optional::<
2993                fidl::encoding::Endpoint<
2994                    fidl::endpoints::ClientEnd<
2995                        fidl_fuchsia_ui_test_input::MouseInputListenerMarker,
2996                    >,
2997                >,
2998                fidl::encoding::DefaultFuchsiaResourceDialect,
2999            >(
3000                self.mouse_listener.as_mut().map(
3001                    <fidl::encoding::Endpoint<
3002                        fidl::endpoints::ClientEnd<
3003                            fidl_fuchsia_ui_test_input::MouseInputListenerMarker,
3004                        >,
3005                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
3006                ),
3007                encoder,
3008                offset + cur_offset,
3009                depth,
3010            )?;
3011
3012            _prev_end_offset = cur_offset + envelope_size;
3013            if 5 > max_ordinal {
3014                return Ok(());
3015            }
3016
3017            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3018            // are envelope_size bytes.
3019            let cur_offset: usize = (5 - 1) * envelope_size;
3020
3021            // Zero reserved fields.
3022            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3023
3024            // Safety:
3025            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3026            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3027            //   envelope_size bytes, there is always sufficient room.
3028            fidl::encoding::encode_in_envelope_optional::<
3029                fidl::encoding::Endpoint<
3030                    fidl::endpoints::ClientEnd<
3031                        fidl_fuchsia_ui_test_input::KeyboardInputListenerMarker,
3032                    >,
3033                >,
3034                fidl::encoding::DefaultFuchsiaResourceDialect,
3035            >(
3036                self.keyboard_listener.as_mut().map(
3037                    <fidl::encoding::Endpoint<
3038                        fidl::endpoints::ClientEnd<
3039                            fidl_fuchsia_ui_test_input::KeyboardInputListenerMarker,
3040                        >,
3041                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
3042                ),
3043                encoder,
3044                offset + cur_offset,
3045                depth,
3046            )?;
3047
3048            _prev_end_offset = cur_offset + envelope_size;
3049            if 6 > max_ordinal {
3050                return Ok(());
3051            }
3052
3053            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3054            // are envelope_size bytes.
3055            let cur_offset: usize = (6 - 1) * envelope_size;
3056
3057            // Zero reserved fields.
3058            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3059
3060            // Safety:
3061            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3062            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3063            //   envelope_size bytes, there is always sufficient room.
3064            fidl::encoding::encode_in_envelope_optional::<
3065                fidl::encoding::Endpoint<
3066                    fidl::endpoints::ClientEnd<fidl_fuchsia_ui_composition::FlatlandMarker>,
3067                >,
3068                fidl::encoding::DefaultFuchsiaResourceDialect,
3069            >(
3070                self.flatland_client.as_mut().map(
3071                    <fidl::encoding::Endpoint<
3072                        fidl::endpoints::ClientEnd<fidl_fuchsia_ui_composition::FlatlandMarker>,
3073                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
3074                ),
3075                encoder,
3076                offset + cur_offset,
3077                depth,
3078            )?;
3079
3080            _prev_end_offset = cur_offset + envelope_size;
3081            if 7 > max_ordinal {
3082                return Ok(());
3083            }
3084
3085            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3086            // are envelope_size bytes.
3087            let cur_offset: usize = (7 - 1) * envelope_size;
3088
3089            // Zero reserved fields.
3090            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3091
3092            // Safety:
3093            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3094            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3095            //   envelope_size bytes, there is always sufficient room.
3096            fidl::encoding::encode_in_envelope_optional::<
3097                fidl::encoding::Endpoint<
3098                    fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardMarker>,
3099                >,
3100                fidl::encoding::DefaultFuchsiaResourceDialect,
3101            >(
3102                self.keyboard_client.as_mut().map(
3103                    <fidl::encoding::Endpoint<
3104                        fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardMarker>,
3105                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
3106                ),
3107                encoder,
3108                offset + cur_offset,
3109                depth,
3110            )?;
3111
3112            _prev_end_offset = cur_offset + envelope_size;
3113            if 8 > max_ordinal {
3114                return Ok(());
3115            }
3116
3117            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3118            // are envelope_size bytes.
3119            let cur_offset: usize = (8 - 1) * envelope_size;
3120
3121            // Zero reserved fields.
3122            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3123
3124            // Safety:
3125            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3126            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3127            //   envelope_size bytes, there is always sufficient room.
3128            fidl::encoding::encode_in_envelope_optional::<
3129                f32,
3130                fidl::encoding::DefaultFuchsiaResourceDialect,
3131            >(
3132                self.device_pixel_ratio
3133                    .as_ref()
3134                    .map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
3135                encoder,
3136                offset + cur_offset,
3137                depth,
3138            )?;
3139
3140            _prev_end_offset = cur_offset + envelope_size;
3141            if 9 > max_ordinal {
3142                return Ok(());
3143            }
3144
3145            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3146            // are envelope_size bytes.
3147            let cur_offset: usize = (9 - 1) * envelope_size;
3148
3149            // Zero reserved fields.
3150            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3151
3152            // Safety:
3153            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3154            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3155            //   envelope_size bytes, there is always sufficient room.
3156            fidl::encoding::encode_in_envelope_optional::<
3157                fidl::encoding::Endpoint<
3158                    fidl::endpoints::ServerEnd<fidl_fuchsia_ui_views::FocuserMarker>,
3159                >,
3160                fidl::encoding::DefaultFuchsiaResourceDialect,
3161            >(
3162                self.focuser.as_mut().map(
3163                    <fidl::encoding::Endpoint<
3164                        fidl::endpoints::ServerEnd<fidl_fuchsia_ui_views::FocuserMarker>,
3165                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
3166                ),
3167                encoder,
3168                offset + cur_offset,
3169                depth,
3170            )?;
3171
3172            _prev_end_offset = cur_offset + envelope_size;
3173
3174            Ok(())
3175        }
3176    }
3177
3178    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
3179        for PuppetCreationArgs
3180    {
3181        #[inline(always)]
3182        fn new_empty() -> Self {
3183            Self::default()
3184        }
3185
3186        unsafe fn decode(
3187            &mut self,
3188            decoder: &mut fidl::encoding::Decoder<
3189                '_,
3190                fidl::encoding::DefaultFuchsiaResourceDialect,
3191            >,
3192            offset: usize,
3193            mut depth: fidl::encoding::Depth,
3194        ) -> fidl::Result<()> {
3195            decoder.debug_check_bounds::<Self>(offset);
3196            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3197                None => return Err(fidl::Error::NotNullable),
3198                Some(len) => len,
3199            };
3200            // Calling decoder.out_of_line_offset(0) is not allowed.
3201            if len == 0 {
3202                return Ok(());
3203            };
3204            depth.increment()?;
3205            let envelope_size = 8;
3206            let bytes_len = len * envelope_size;
3207            let offset = decoder.out_of_line_offset(bytes_len)?;
3208            // Decode the envelope for each type.
3209            let mut _next_ordinal_to_read = 0;
3210            let mut next_offset = offset;
3211            let end_offset = offset + bytes_len;
3212            _next_ordinal_to_read += 1;
3213            if next_offset >= end_offset {
3214                return Ok(());
3215            }
3216
3217            // Decode unknown envelopes for gaps in ordinals.
3218            while _next_ordinal_to_read < 1 {
3219                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3220                _next_ordinal_to_read += 1;
3221                next_offset += envelope_size;
3222            }
3223
3224            let next_out_of_line = decoder.next_out_of_line();
3225            let handles_before = decoder.remaining_handles();
3226            if let Some((inlined, num_bytes, num_handles)) =
3227                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3228            {
3229                let member_inline_size = <fidl::encoding::Endpoint<
3230                    fidl::endpoints::ServerEnd<PuppetMarker>,
3231                > as fidl::encoding::TypeMarker>::inline_size(
3232                    decoder.context
3233                );
3234                if inlined != (member_inline_size <= 4) {
3235                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3236                }
3237                let inner_offset;
3238                let mut inner_depth = depth.clone();
3239                if inlined {
3240                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3241                    inner_offset = next_offset;
3242                } else {
3243                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3244                    inner_depth.increment()?;
3245                }
3246                let val_ref = self.server_end.get_or_insert_with(|| {
3247                    fidl::new_empty!(
3248                        fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PuppetMarker>>,
3249                        fidl::encoding::DefaultFuchsiaResourceDialect
3250                    )
3251                });
3252                fidl::decode!(
3253                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<PuppetMarker>>,
3254                    fidl::encoding::DefaultFuchsiaResourceDialect,
3255                    val_ref,
3256                    decoder,
3257                    inner_offset,
3258                    inner_depth
3259                )?;
3260                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3261                {
3262                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3263                }
3264                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3265                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3266                }
3267            }
3268
3269            next_offset += envelope_size;
3270            _next_ordinal_to_read += 1;
3271            if next_offset >= end_offset {
3272                return Ok(());
3273            }
3274
3275            // Decode unknown envelopes for gaps in ordinals.
3276            while _next_ordinal_to_read < 2 {
3277                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3278                _next_ordinal_to_read += 1;
3279                next_offset += envelope_size;
3280            }
3281
3282            let next_out_of_line = decoder.next_out_of_line();
3283            let handles_before = decoder.remaining_handles();
3284            if let Some((inlined, num_bytes, num_handles)) =
3285                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3286            {
3287                let member_inline_size = <fidl_fuchsia_ui_views::ViewCreationToken as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3288                if inlined != (member_inline_size <= 4) {
3289                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3290                }
3291                let inner_offset;
3292                let mut inner_depth = depth.clone();
3293                if inlined {
3294                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3295                    inner_offset = next_offset;
3296                } else {
3297                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3298                    inner_depth.increment()?;
3299                }
3300                let val_ref = self.view_token.get_or_insert_with(|| {
3301                    fidl::new_empty!(
3302                        fidl_fuchsia_ui_views::ViewCreationToken,
3303                        fidl::encoding::DefaultFuchsiaResourceDialect
3304                    )
3305                });
3306                fidl::decode!(
3307                    fidl_fuchsia_ui_views::ViewCreationToken,
3308                    fidl::encoding::DefaultFuchsiaResourceDialect,
3309                    val_ref,
3310                    decoder,
3311                    inner_offset,
3312                    inner_depth
3313                )?;
3314                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3315                {
3316                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3317                }
3318                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3319                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3320                }
3321            }
3322
3323            next_offset += envelope_size;
3324            _next_ordinal_to_read += 1;
3325            if next_offset >= end_offset {
3326                return Ok(());
3327            }
3328
3329            // Decode unknown envelopes for gaps in ordinals.
3330            while _next_ordinal_to_read < 3 {
3331                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3332                _next_ordinal_to_read += 1;
3333                next_offset += envelope_size;
3334            }
3335
3336            let next_out_of_line = decoder.next_out_of_line();
3337            let handles_before = decoder.remaining_handles();
3338            if let Some((inlined, num_bytes, num_handles)) =
3339                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3340            {
3341                let member_inline_size = <fidl::encoding::Endpoint<
3342                    fidl::endpoints::ClientEnd<
3343                        fidl_fuchsia_ui_test_input::TouchInputListenerMarker,
3344                    >,
3345                > as fidl::encoding::TypeMarker>::inline_size(
3346                    decoder.context
3347                );
3348                if inlined != (member_inline_size <= 4) {
3349                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3350                }
3351                let inner_offset;
3352                let mut inner_depth = depth.clone();
3353                if inlined {
3354                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3355                    inner_offset = next_offset;
3356                } else {
3357                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3358                    inner_depth.increment()?;
3359                }
3360                let val_ref = self.touch_listener.get_or_insert_with(|| {
3361                    fidl::new_empty!(
3362                        fidl::encoding::Endpoint<
3363                            fidl::endpoints::ClientEnd<
3364                                fidl_fuchsia_ui_test_input::TouchInputListenerMarker,
3365                            >,
3366                        >,
3367                        fidl::encoding::DefaultFuchsiaResourceDialect
3368                    )
3369                });
3370                fidl::decode!(
3371                    fidl::encoding::Endpoint<
3372                        fidl::endpoints::ClientEnd<
3373                            fidl_fuchsia_ui_test_input::TouchInputListenerMarker,
3374                        >,
3375                    >,
3376                    fidl::encoding::DefaultFuchsiaResourceDialect,
3377                    val_ref,
3378                    decoder,
3379                    inner_offset,
3380                    inner_depth
3381                )?;
3382                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3383                {
3384                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3385                }
3386                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3387                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3388                }
3389            }
3390
3391            next_offset += envelope_size;
3392            _next_ordinal_to_read += 1;
3393            if next_offset >= end_offset {
3394                return Ok(());
3395            }
3396
3397            // Decode unknown envelopes for gaps in ordinals.
3398            while _next_ordinal_to_read < 4 {
3399                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3400                _next_ordinal_to_read += 1;
3401                next_offset += envelope_size;
3402            }
3403
3404            let next_out_of_line = decoder.next_out_of_line();
3405            let handles_before = decoder.remaining_handles();
3406            if let Some((inlined, num_bytes, num_handles)) =
3407                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3408            {
3409                let member_inline_size = <fidl::encoding::Endpoint<
3410                    fidl::endpoints::ClientEnd<
3411                        fidl_fuchsia_ui_test_input::MouseInputListenerMarker,
3412                    >,
3413                > as fidl::encoding::TypeMarker>::inline_size(
3414                    decoder.context
3415                );
3416                if inlined != (member_inline_size <= 4) {
3417                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3418                }
3419                let inner_offset;
3420                let mut inner_depth = depth.clone();
3421                if inlined {
3422                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3423                    inner_offset = next_offset;
3424                } else {
3425                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3426                    inner_depth.increment()?;
3427                }
3428                let val_ref = self.mouse_listener.get_or_insert_with(|| {
3429                    fidl::new_empty!(
3430                        fidl::encoding::Endpoint<
3431                            fidl::endpoints::ClientEnd<
3432                                fidl_fuchsia_ui_test_input::MouseInputListenerMarker,
3433                            >,
3434                        >,
3435                        fidl::encoding::DefaultFuchsiaResourceDialect
3436                    )
3437                });
3438                fidl::decode!(
3439                    fidl::encoding::Endpoint<
3440                        fidl::endpoints::ClientEnd<
3441                            fidl_fuchsia_ui_test_input::MouseInputListenerMarker,
3442                        >,
3443                    >,
3444                    fidl::encoding::DefaultFuchsiaResourceDialect,
3445                    val_ref,
3446                    decoder,
3447                    inner_offset,
3448                    inner_depth
3449                )?;
3450                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3451                {
3452                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3453                }
3454                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3455                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3456                }
3457            }
3458
3459            next_offset += envelope_size;
3460            _next_ordinal_to_read += 1;
3461            if next_offset >= end_offset {
3462                return Ok(());
3463            }
3464
3465            // Decode unknown envelopes for gaps in ordinals.
3466            while _next_ordinal_to_read < 5 {
3467                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3468                _next_ordinal_to_read += 1;
3469                next_offset += envelope_size;
3470            }
3471
3472            let next_out_of_line = decoder.next_out_of_line();
3473            let handles_before = decoder.remaining_handles();
3474            if let Some((inlined, num_bytes, num_handles)) =
3475                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3476            {
3477                let member_inline_size = <fidl::encoding::Endpoint<
3478                    fidl::endpoints::ClientEnd<
3479                        fidl_fuchsia_ui_test_input::KeyboardInputListenerMarker,
3480                    >,
3481                > as fidl::encoding::TypeMarker>::inline_size(
3482                    decoder.context
3483                );
3484                if inlined != (member_inline_size <= 4) {
3485                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3486                }
3487                let inner_offset;
3488                let mut inner_depth = depth.clone();
3489                if inlined {
3490                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3491                    inner_offset = next_offset;
3492                } else {
3493                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3494                    inner_depth.increment()?;
3495                }
3496                let val_ref = self.keyboard_listener.get_or_insert_with(|| {
3497                    fidl::new_empty!(
3498                        fidl::encoding::Endpoint<
3499                            fidl::endpoints::ClientEnd<
3500                                fidl_fuchsia_ui_test_input::KeyboardInputListenerMarker,
3501                            >,
3502                        >,
3503                        fidl::encoding::DefaultFuchsiaResourceDialect
3504                    )
3505                });
3506                fidl::decode!(
3507                    fidl::encoding::Endpoint<
3508                        fidl::endpoints::ClientEnd<
3509                            fidl_fuchsia_ui_test_input::KeyboardInputListenerMarker,
3510                        >,
3511                    >,
3512                    fidl::encoding::DefaultFuchsiaResourceDialect,
3513                    val_ref,
3514                    decoder,
3515                    inner_offset,
3516                    inner_depth
3517                )?;
3518                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3519                {
3520                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3521                }
3522                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3523                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3524                }
3525            }
3526
3527            next_offset += envelope_size;
3528            _next_ordinal_to_read += 1;
3529            if next_offset >= end_offset {
3530                return Ok(());
3531            }
3532
3533            // Decode unknown envelopes for gaps in ordinals.
3534            while _next_ordinal_to_read < 6 {
3535                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3536                _next_ordinal_to_read += 1;
3537                next_offset += envelope_size;
3538            }
3539
3540            let next_out_of_line = decoder.next_out_of_line();
3541            let handles_before = decoder.remaining_handles();
3542            if let Some((inlined, num_bytes, num_handles)) =
3543                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3544            {
3545                let member_inline_size = <fidl::encoding::Endpoint<
3546                    fidl::endpoints::ClientEnd<fidl_fuchsia_ui_composition::FlatlandMarker>,
3547                > as fidl::encoding::TypeMarker>::inline_size(
3548                    decoder.context
3549                );
3550                if inlined != (member_inline_size <= 4) {
3551                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3552                }
3553                let inner_offset;
3554                let mut inner_depth = depth.clone();
3555                if inlined {
3556                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3557                    inner_offset = next_offset;
3558                } else {
3559                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3560                    inner_depth.increment()?;
3561                }
3562                let val_ref = self.flatland_client.get_or_insert_with(|| {
3563                    fidl::new_empty!(
3564                        fidl::encoding::Endpoint<
3565                            fidl::endpoints::ClientEnd<fidl_fuchsia_ui_composition::FlatlandMarker>,
3566                        >,
3567                        fidl::encoding::DefaultFuchsiaResourceDialect
3568                    )
3569                });
3570                fidl::decode!(
3571                    fidl::encoding::Endpoint<
3572                        fidl::endpoints::ClientEnd<fidl_fuchsia_ui_composition::FlatlandMarker>,
3573                    >,
3574                    fidl::encoding::DefaultFuchsiaResourceDialect,
3575                    val_ref,
3576                    decoder,
3577                    inner_offset,
3578                    inner_depth
3579                )?;
3580                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3581                {
3582                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3583                }
3584                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3585                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3586                }
3587            }
3588
3589            next_offset += envelope_size;
3590            _next_ordinal_to_read += 1;
3591            if next_offset >= end_offset {
3592                return Ok(());
3593            }
3594
3595            // Decode unknown envelopes for gaps in ordinals.
3596            while _next_ordinal_to_read < 7 {
3597                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3598                _next_ordinal_to_read += 1;
3599                next_offset += envelope_size;
3600            }
3601
3602            let next_out_of_line = decoder.next_out_of_line();
3603            let handles_before = decoder.remaining_handles();
3604            if let Some((inlined, num_bytes, num_handles)) =
3605                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3606            {
3607                let member_inline_size = <fidl::encoding::Endpoint<
3608                    fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardMarker>,
3609                > as fidl::encoding::TypeMarker>::inline_size(
3610                    decoder.context
3611                );
3612                if inlined != (member_inline_size <= 4) {
3613                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3614                }
3615                let inner_offset;
3616                let mut inner_depth = depth.clone();
3617                if inlined {
3618                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3619                    inner_offset = next_offset;
3620                } else {
3621                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3622                    inner_depth.increment()?;
3623                }
3624                let val_ref = self.keyboard_client.get_or_insert_with(|| {
3625                    fidl::new_empty!(
3626                        fidl::encoding::Endpoint<
3627                            fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardMarker>,
3628                        >,
3629                        fidl::encoding::DefaultFuchsiaResourceDialect
3630                    )
3631                });
3632                fidl::decode!(
3633                    fidl::encoding::Endpoint<
3634                        fidl::endpoints::ClientEnd<fidl_fuchsia_ui_input3::KeyboardMarker>,
3635                    >,
3636                    fidl::encoding::DefaultFuchsiaResourceDialect,
3637                    val_ref,
3638                    decoder,
3639                    inner_offset,
3640                    inner_depth
3641                )?;
3642                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3643                {
3644                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3645                }
3646                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3647                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3648                }
3649            }
3650
3651            next_offset += envelope_size;
3652            _next_ordinal_to_read += 1;
3653            if next_offset >= end_offset {
3654                return Ok(());
3655            }
3656
3657            // Decode unknown envelopes for gaps in ordinals.
3658            while _next_ordinal_to_read < 8 {
3659                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3660                _next_ordinal_to_read += 1;
3661                next_offset += envelope_size;
3662            }
3663
3664            let next_out_of_line = decoder.next_out_of_line();
3665            let handles_before = decoder.remaining_handles();
3666            if let Some((inlined, num_bytes, num_handles)) =
3667                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3668            {
3669                let member_inline_size =
3670                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3671                if inlined != (member_inline_size <= 4) {
3672                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3673                }
3674                let inner_offset;
3675                let mut inner_depth = depth.clone();
3676                if inlined {
3677                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3678                    inner_offset = next_offset;
3679                } else {
3680                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3681                    inner_depth.increment()?;
3682                }
3683                let val_ref = self.device_pixel_ratio.get_or_insert_with(|| {
3684                    fidl::new_empty!(f32, fidl::encoding::DefaultFuchsiaResourceDialect)
3685                });
3686                fidl::decode!(
3687                    f32,
3688                    fidl::encoding::DefaultFuchsiaResourceDialect,
3689                    val_ref,
3690                    decoder,
3691                    inner_offset,
3692                    inner_depth
3693                )?;
3694                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3695                {
3696                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3697                }
3698                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3699                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3700                }
3701            }
3702
3703            next_offset += envelope_size;
3704            _next_ordinal_to_read += 1;
3705            if next_offset >= end_offset {
3706                return Ok(());
3707            }
3708
3709            // Decode unknown envelopes for gaps in ordinals.
3710            while _next_ordinal_to_read < 9 {
3711                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3712                _next_ordinal_to_read += 1;
3713                next_offset += envelope_size;
3714            }
3715
3716            let next_out_of_line = decoder.next_out_of_line();
3717            let handles_before = decoder.remaining_handles();
3718            if let Some((inlined, num_bytes, num_handles)) =
3719                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3720            {
3721                let member_inline_size = <fidl::encoding::Endpoint<
3722                    fidl::endpoints::ServerEnd<fidl_fuchsia_ui_views::FocuserMarker>,
3723                > as fidl::encoding::TypeMarker>::inline_size(
3724                    decoder.context
3725                );
3726                if inlined != (member_inline_size <= 4) {
3727                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3728                }
3729                let inner_offset;
3730                let mut inner_depth = depth.clone();
3731                if inlined {
3732                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3733                    inner_offset = next_offset;
3734                } else {
3735                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3736                    inner_depth.increment()?;
3737                }
3738                let val_ref = self.focuser.get_or_insert_with(|| {
3739                    fidl::new_empty!(
3740                        fidl::encoding::Endpoint<
3741                            fidl::endpoints::ServerEnd<fidl_fuchsia_ui_views::FocuserMarker>,
3742                        >,
3743                        fidl::encoding::DefaultFuchsiaResourceDialect
3744                    )
3745                });
3746                fidl::decode!(
3747                    fidl::encoding::Endpoint<
3748                        fidl::endpoints::ServerEnd<fidl_fuchsia_ui_views::FocuserMarker>,
3749                    >,
3750                    fidl::encoding::DefaultFuchsiaResourceDialect,
3751                    val_ref,
3752                    decoder,
3753                    inner_offset,
3754                    inner_depth
3755                )?;
3756                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3757                {
3758                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3759                }
3760                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3761                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3762                }
3763            }
3764
3765            next_offset += envelope_size;
3766
3767            // Decode the remaining unknown envelopes.
3768            while next_offset < end_offset {
3769                _next_ordinal_to_read += 1;
3770                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3771                next_offset += envelope_size;
3772            }
3773
3774            Ok(())
3775        }
3776    }
3777
3778    impl PuppetDrawImageRequest {
3779        #[inline(always)]
3780        fn max_ordinal_present(&self) -> u64 {
3781            if let Some(_) = self.properties {
3782                return 2;
3783            }
3784            if let Some(_) = self.id {
3785                return 1;
3786            }
3787            0
3788        }
3789    }
3790
3791    impl fidl::encoding::ValueTypeMarker for PuppetDrawImageRequest {
3792        type Borrowed<'a> = &'a Self;
3793        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3794            value
3795        }
3796    }
3797
3798    unsafe impl fidl::encoding::TypeMarker for PuppetDrawImageRequest {
3799        type Owned = Self;
3800
3801        #[inline(always)]
3802        fn inline_align(_context: fidl::encoding::Context) -> usize {
3803            8
3804        }
3805
3806        #[inline(always)]
3807        fn inline_size(_context: fidl::encoding::Context) -> usize {
3808            16
3809        }
3810    }
3811
3812    unsafe impl<D: fidl::encoding::ResourceDialect>
3813        fidl::encoding::Encode<PuppetDrawImageRequest, D> for &PuppetDrawImageRequest
3814    {
3815        unsafe fn encode(
3816            self,
3817            encoder: &mut fidl::encoding::Encoder<'_, D>,
3818            offset: usize,
3819            mut depth: fidl::encoding::Depth,
3820        ) -> fidl::Result<()> {
3821            encoder.debug_check_bounds::<PuppetDrawImageRequest>(offset);
3822            // Vector header
3823            let max_ordinal: u64 = self.max_ordinal_present();
3824            encoder.write_num(max_ordinal, offset);
3825            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3826            // Calling encoder.out_of_line_offset(0) is not allowed.
3827            if max_ordinal == 0 {
3828                return Ok(());
3829            }
3830            depth.increment()?;
3831            let envelope_size = 8;
3832            let bytes_len = max_ordinal as usize * envelope_size;
3833            #[allow(unused_variables)]
3834            let offset = encoder.out_of_line_offset(bytes_len);
3835            let mut _prev_end_offset: usize = 0;
3836            if 1 > max_ordinal {
3837                return Ok(());
3838            }
3839
3840            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3841            // are envelope_size bytes.
3842            let cur_offset: usize = (1 - 1) * envelope_size;
3843
3844            // Zero reserved fields.
3845            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3846
3847            // Safety:
3848            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3849            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3850            //   envelope_size bytes, there is always sufficient room.
3851            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3852                self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3853                encoder,
3854                offset + cur_offset,
3855                depth,
3856            )?;
3857
3858            _prev_end_offset = cur_offset + envelope_size;
3859            if 2 > max_ordinal {
3860                return Ok(());
3861            }
3862
3863            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3864            // are envelope_size bytes.
3865            let cur_offset: usize = (2 - 1) * envelope_size;
3866
3867            // Zero reserved fields.
3868            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3869
3870            // Safety:
3871            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3872            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3873            //   envelope_size bytes, there is always sufficient room.
3874            fidl::encoding::encode_in_envelope_optional::<ImageProperties, D>(
3875                self.properties
3876                    .as_ref()
3877                    .map(<ImageProperties as fidl::encoding::ValueTypeMarker>::borrow),
3878                encoder,
3879                offset + cur_offset,
3880                depth,
3881            )?;
3882
3883            _prev_end_offset = cur_offset + envelope_size;
3884
3885            Ok(())
3886        }
3887    }
3888
3889    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3890        for PuppetDrawImageRequest
3891    {
3892        #[inline(always)]
3893        fn new_empty() -> Self {
3894            Self::default()
3895        }
3896
3897        unsafe fn decode(
3898            &mut self,
3899            decoder: &mut fidl::encoding::Decoder<'_, D>,
3900            offset: usize,
3901            mut depth: fidl::encoding::Depth,
3902        ) -> fidl::Result<()> {
3903            decoder.debug_check_bounds::<Self>(offset);
3904            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3905                None => return Err(fidl::Error::NotNullable),
3906                Some(len) => len,
3907            };
3908            // Calling decoder.out_of_line_offset(0) is not allowed.
3909            if len == 0 {
3910                return Ok(());
3911            };
3912            depth.increment()?;
3913            let envelope_size = 8;
3914            let bytes_len = len * envelope_size;
3915            let offset = decoder.out_of_line_offset(bytes_len)?;
3916            // Decode the envelope for each type.
3917            let mut _next_ordinal_to_read = 0;
3918            let mut next_offset = offset;
3919            let end_offset = offset + bytes_len;
3920            _next_ordinal_to_read += 1;
3921            if next_offset >= end_offset {
3922                return Ok(());
3923            }
3924
3925            // Decode unknown envelopes for gaps in ordinals.
3926            while _next_ordinal_to_read < 1 {
3927                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3928                _next_ordinal_to_read += 1;
3929                next_offset += envelope_size;
3930            }
3931
3932            let next_out_of_line = decoder.next_out_of_line();
3933            let handles_before = decoder.remaining_handles();
3934            if let Some((inlined, num_bytes, num_handles)) =
3935                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3936            {
3937                let member_inline_size =
3938                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3939                if inlined != (member_inline_size <= 4) {
3940                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3941                }
3942                let inner_offset;
3943                let mut inner_depth = depth.clone();
3944                if inlined {
3945                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3946                    inner_offset = next_offset;
3947                } else {
3948                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3949                    inner_depth.increment()?;
3950                }
3951                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
3952                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3953                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3954                {
3955                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3956                }
3957                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3958                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3959                }
3960            }
3961
3962            next_offset += envelope_size;
3963            _next_ordinal_to_read += 1;
3964            if next_offset >= end_offset {
3965                return Ok(());
3966            }
3967
3968            // Decode unknown envelopes for gaps in ordinals.
3969            while _next_ordinal_to_read < 2 {
3970                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3971                _next_ordinal_to_read += 1;
3972                next_offset += envelope_size;
3973            }
3974
3975            let next_out_of_line = decoder.next_out_of_line();
3976            let handles_before = decoder.remaining_handles();
3977            if let Some((inlined, num_bytes, num_handles)) =
3978                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3979            {
3980                let member_inline_size =
3981                    <ImageProperties as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3982                if inlined != (member_inline_size <= 4) {
3983                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3984                }
3985                let inner_offset;
3986                let mut inner_depth = depth.clone();
3987                if inlined {
3988                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3989                    inner_offset = next_offset;
3990                } else {
3991                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3992                    inner_depth.increment()?;
3993                }
3994                let val_ref =
3995                    self.properties.get_or_insert_with(|| fidl::new_empty!(ImageProperties, D));
3996                fidl::decode!(ImageProperties, D, val_ref, decoder, inner_offset, inner_depth)?;
3997                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3998                {
3999                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4000                }
4001                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4002                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4003                }
4004            }
4005
4006            next_offset += envelope_size;
4007
4008            // Decode the remaining unknown envelopes.
4009            while next_offset < end_offset {
4010                _next_ordinal_to_read += 1;
4011                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4012                next_offset += envelope_size;
4013            }
4014
4015            Ok(())
4016        }
4017    }
4018
4019    impl PuppetDrawImageResponse {
4020        #[inline(always)]
4021        fn max_ordinal_present(&self) -> u64 {
4022            if let Some(_) = self.result {
4023                return 1;
4024            }
4025            0
4026        }
4027    }
4028
4029    impl fidl::encoding::ValueTypeMarker for PuppetDrawImageResponse {
4030        type Borrowed<'a> = &'a Self;
4031        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4032            value
4033        }
4034    }
4035
4036    unsafe impl fidl::encoding::TypeMarker for PuppetDrawImageResponse {
4037        type Owned = Self;
4038
4039        #[inline(always)]
4040        fn inline_align(_context: fidl::encoding::Context) -> usize {
4041            8
4042        }
4043
4044        #[inline(always)]
4045        fn inline_size(_context: fidl::encoding::Context) -> usize {
4046            16
4047        }
4048    }
4049
4050    unsafe impl<D: fidl::encoding::ResourceDialect>
4051        fidl::encoding::Encode<PuppetDrawImageResponse, D> for &PuppetDrawImageResponse
4052    {
4053        unsafe fn encode(
4054            self,
4055            encoder: &mut fidl::encoding::Encoder<'_, D>,
4056            offset: usize,
4057            mut depth: fidl::encoding::Depth,
4058        ) -> fidl::Result<()> {
4059            encoder.debug_check_bounds::<PuppetDrawImageResponse>(offset);
4060            // Vector header
4061            let max_ordinal: u64 = self.max_ordinal_present();
4062            encoder.write_num(max_ordinal, offset);
4063            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4064            // Calling encoder.out_of_line_offset(0) is not allowed.
4065            if max_ordinal == 0 {
4066                return Ok(());
4067            }
4068            depth.increment()?;
4069            let envelope_size = 8;
4070            let bytes_len = max_ordinal as usize * envelope_size;
4071            #[allow(unused_variables)]
4072            let offset = encoder.out_of_line_offset(bytes_len);
4073            let mut _prev_end_offset: usize = 0;
4074            if 1 > max_ordinal {
4075                return Ok(());
4076            }
4077
4078            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4079            // are envelope_size bytes.
4080            let cur_offset: usize = (1 - 1) * envelope_size;
4081
4082            // Zero reserved fields.
4083            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4084
4085            // Safety:
4086            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4087            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4088            //   envelope_size bytes, there is always sufficient room.
4089            fidl::encoding::encode_in_envelope_optional::<Result_, D>(
4090                self.result.as_ref().map(<Result_ as fidl::encoding::ValueTypeMarker>::borrow),
4091                encoder,
4092                offset + cur_offset,
4093                depth,
4094            )?;
4095
4096            _prev_end_offset = cur_offset + envelope_size;
4097
4098            Ok(())
4099        }
4100    }
4101
4102    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4103        for PuppetDrawImageResponse
4104    {
4105        #[inline(always)]
4106        fn new_empty() -> Self {
4107            Self::default()
4108        }
4109
4110        unsafe fn decode(
4111            &mut self,
4112            decoder: &mut fidl::encoding::Decoder<'_, D>,
4113            offset: usize,
4114            mut depth: fidl::encoding::Depth,
4115        ) -> fidl::Result<()> {
4116            decoder.debug_check_bounds::<Self>(offset);
4117            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4118                None => return Err(fidl::Error::NotNullable),
4119                Some(len) => len,
4120            };
4121            // Calling decoder.out_of_line_offset(0) is not allowed.
4122            if len == 0 {
4123                return Ok(());
4124            };
4125            depth.increment()?;
4126            let envelope_size = 8;
4127            let bytes_len = len * envelope_size;
4128            let offset = decoder.out_of_line_offset(bytes_len)?;
4129            // Decode the envelope for each type.
4130            let mut _next_ordinal_to_read = 0;
4131            let mut next_offset = offset;
4132            let end_offset = offset + bytes_len;
4133            _next_ordinal_to_read += 1;
4134            if next_offset >= end_offset {
4135                return Ok(());
4136            }
4137
4138            // Decode unknown envelopes for gaps in ordinals.
4139            while _next_ordinal_to_read < 1 {
4140                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4141                _next_ordinal_to_read += 1;
4142                next_offset += envelope_size;
4143            }
4144
4145            let next_out_of_line = decoder.next_out_of_line();
4146            let handles_before = decoder.remaining_handles();
4147            if let Some((inlined, num_bytes, num_handles)) =
4148                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4149            {
4150                let member_inline_size =
4151                    <Result_ as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4152                if inlined != (member_inline_size <= 4) {
4153                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4154                }
4155                let inner_offset;
4156                let mut inner_depth = depth.clone();
4157                if inlined {
4158                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4159                    inner_offset = next_offset;
4160                } else {
4161                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4162                    inner_depth.increment()?;
4163                }
4164                let val_ref = self.result.get_or_insert_with(|| fidl::new_empty!(Result_, D));
4165                fidl::decode!(Result_, D, val_ref, decoder, inner_offset, inner_depth)?;
4166                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4167                {
4168                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4169                }
4170                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4171                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4172                }
4173            }
4174
4175            next_offset += envelope_size;
4176
4177            // Decode the remaining unknown envelopes.
4178            while next_offset < end_offset {
4179                _next_ordinal_to_read += 1;
4180                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4181                next_offset += envelope_size;
4182            }
4183
4184            Ok(())
4185        }
4186    }
4187
4188    impl PuppetEmbedRemoteViewRequest {
4189        #[inline(always)]
4190        fn max_ordinal_present(&self) -> u64 {
4191            if let Some(_) = self.properties {
4192                return 2;
4193            }
4194            if let Some(_) = self.id {
4195                return 1;
4196            }
4197            0
4198        }
4199    }
4200
4201    impl fidl::encoding::ValueTypeMarker for PuppetEmbedRemoteViewRequest {
4202        type Borrowed<'a> = &'a Self;
4203        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4204            value
4205        }
4206    }
4207
4208    unsafe impl fidl::encoding::TypeMarker for PuppetEmbedRemoteViewRequest {
4209        type Owned = Self;
4210
4211        #[inline(always)]
4212        fn inline_align(_context: fidl::encoding::Context) -> usize {
4213            8
4214        }
4215
4216        #[inline(always)]
4217        fn inline_size(_context: fidl::encoding::Context) -> usize {
4218            16
4219        }
4220    }
4221
4222    unsafe impl<D: fidl::encoding::ResourceDialect>
4223        fidl::encoding::Encode<PuppetEmbedRemoteViewRequest, D> for &PuppetEmbedRemoteViewRequest
4224    {
4225        unsafe fn encode(
4226            self,
4227            encoder: &mut fidl::encoding::Encoder<'_, D>,
4228            offset: usize,
4229            mut depth: fidl::encoding::Depth,
4230        ) -> fidl::Result<()> {
4231            encoder.debug_check_bounds::<PuppetEmbedRemoteViewRequest>(offset);
4232            // Vector header
4233            let max_ordinal: u64 = self.max_ordinal_present();
4234            encoder.write_num(max_ordinal, offset);
4235            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4236            // Calling encoder.out_of_line_offset(0) is not allowed.
4237            if max_ordinal == 0 {
4238                return Ok(());
4239            }
4240            depth.increment()?;
4241            let envelope_size = 8;
4242            let bytes_len = max_ordinal as usize * envelope_size;
4243            #[allow(unused_variables)]
4244            let offset = encoder.out_of_line_offset(bytes_len);
4245            let mut _prev_end_offset: usize = 0;
4246            if 1 > max_ordinal {
4247                return Ok(());
4248            }
4249
4250            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4251            // are envelope_size bytes.
4252            let cur_offset: usize = (1 - 1) * envelope_size;
4253
4254            // Zero reserved fields.
4255            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4256
4257            // Safety:
4258            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4259            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4260            //   envelope_size bytes, there is always sufficient room.
4261            fidl::encoding::encode_in_envelope_optional::<u64, D>(
4262                self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4263                encoder,
4264                offset + cur_offset,
4265                depth,
4266            )?;
4267
4268            _prev_end_offset = cur_offset + envelope_size;
4269            if 2 > max_ordinal {
4270                return Ok(());
4271            }
4272
4273            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4274            // are envelope_size bytes.
4275            let cur_offset: usize = (2 - 1) * envelope_size;
4276
4277            // Zero reserved fields.
4278            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4279
4280            // Safety:
4281            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4282            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4283            //   envelope_size bytes, there is always sufficient room.
4284            fidl::encoding::encode_in_envelope_optional::<EmbeddedViewProperties, D>(
4285                self.properties
4286                    .as_ref()
4287                    .map(<EmbeddedViewProperties as fidl::encoding::ValueTypeMarker>::borrow),
4288                encoder,
4289                offset + cur_offset,
4290                depth,
4291            )?;
4292
4293            _prev_end_offset = cur_offset + envelope_size;
4294
4295            Ok(())
4296        }
4297    }
4298
4299    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4300        for PuppetEmbedRemoteViewRequest
4301    {
4302        #[inline(always)]
4303        fn new_empty() -> Self {
4304            Self::default()
4305        }
4306
4307        unsafe fn decode(
4308            &mut self,
4309            decoder: &mut fidl::encoding::Decoder<'_, D>,
4310            offset: usize,
4311            mut depth: fidl::encoding::Depth,
4312        ) -> fidl::Result<()> {
4313            decoder.debug_check_bounds::<Self>(offset);
4314            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4315                None => return Err(fidl::Error::NotNullable),
4316                Some(len) => len,
4317            };
4318            // Calling decoder.out_of_line_offset(0) is not allowed.
4319            if len == 0 {
4320                return Ok(());
4321            };
4322            depth.increment()?;
4323            let envelope_size = 8;
4324            let bytes_len = len * envelope_size;
4325            let offset = decoder.out_of_line_offset(bytes_len)?;
4326            // Decode the envelope for each type.
4327            let mut _next_ordinal_to_read = 0;
4328            let mut next_offset = offset;
4329            let end_offset = offset + bytes_len;
4330            _next_ordinal_to_read += 1;
4331            if next_offset >= end_offset {
4332                return Ok(());
4333            }
4334
4335            // Decode unknown envelopes for gaps in ordinals.
4336            while _next_ordinal_to_read < 1 {
4337                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4338                _next_ordinal_to_read += 1;
4339                next_offset += envelope_size;
4340            }
4341
4342            let next_out_of_line = decoder.next_out_of_line();
4343            let handles_before = decoder.remaining_handles();
4344            if let Some((inlined, num_bytes, num_handles)) =
4345                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4346            {
4347                let member_inline_size =
4348                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4349                if inlined != (member_inline_size <= 4) {
4350                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4351                }
4352                let inner_offset;
4353                let mut inner_depth = depth.clone();
4354                if inlined {
4355                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4356                    inner_offset = next_offset;
4357                } else {
4358                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4359                    inner_depth.increment()?;
4360                }
4361                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
4362                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4363                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4364                {
4365                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4366                }
4367                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4368                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4369                }
4370            }
4371
4372            next_offset += envelope_size;
4373            _next_ordinal_to_read += 1;
4374            if next_offset >= end_offset {
4375                return Ok(());
4376            }
4377
4378            // Decode unknown envelopes for gaps in ordinals.
4379            while _next_ordinal_to_read < 2 {
4380                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4381                _next_ordinal_to_read += 1;
4382                next_offset += envelope_size;
4383            }
4384
4385            let next_out_of_line = decoder.next_out_of_line();
4386            let handles_before = decoder.remaining_handles();
4387            if let Some((inlined, num_bytes, num_handles)) =
4388                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4389            {
4390                let member_inline_size =
4391                    <EmbeddedViewProperties as fidl::encoding::TypeMarker>::inline_size(
4392                        decoder.context,
4393                    );
4394                if inlined != (member_inline_size <= 4) {
4395                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4396                }
4397                let inner_offset;
4398                let mut inner_depth = depth.clone();
4399                if inlined {
4400                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4401                    inner_offset = next_offset;
4402                } else {
4403                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4404                    inner_depth.increment()?;
4405                }
4406                let val_ref = self
4407                    .properties
4408                    .get_or_insert_with(|| fidl::new_empty!(EmbeddedViewProperties, D));
4409                fidl::decode!(
4410                    EmbeddedViewProperties,
4411                    D,
4412                    val_ref,
4413                    decoder,
4414                    inner_offset,
4415                    inner_depth
4416                )?;
4417                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4418                {
4419                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4420                }
4421                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4422                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4423                }
4424            }
4425
4426            next_offset += envelope_size;
4427
4428            // Decode the remaining unknown envelopes.
4429            while next_offset < end_offset {
4430                _next_ordinal_to_read += 1;
4431                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4432                next_offset += envelope_size;
4433            }
4434
4435            Ok(())
4436        }
4437    }
4438
4439    impl PuppetEmbedRemoteViewResponse {
4440        #[inline(always)]
4441        fn max_ordinal_present(&self) -> u64 {
4442            if let Some(_) = self.view_creation_token {
4443                return 2;
4444            }
4445            if let Some(_) = self.result {
4446                return 1;
4447            }
4448            0
4449        }
4450    }
4451
4452    impl fidl::encoding::ResourceTypeMarker for PuppetEmbedRemoteViewResponse {
4453        type Borrowed<'a> = &'a mut Self;
4454        fn take_or_borrow<'a>(
4455            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
4456        ) -> Self::Borrowed<'a> {
4457            value
4458        }
4459    }
4460
4461    unsafe impl fidl::encoding::TypeMarker for PuppetEmbedRemoteViewResponse {
4462        type Owned = Self;
4463
4464        #[inline(always)]
4465        fn inline_align(_context: fidl::encoding::Context) -> usize {
4466            8
4467        }
4468
4469        #[inline(always)]
4470        fn inline_size(_context: fidl::encoding::Context) -> usize {
4471            16
4472        }
4473    }
4474
4475    unsafe impl
4476        fidl::encoding::Encode<
4477            PuppetEmbedRemoteViewResponse,
4478            fidl::encoding::DefaultFuchsiaResourceDialect,
4479        > for &mut PuppetEmbedRemoteViewResponse
4480    {
4481        unsafe fn encode(
4482            self,
4483            encoder: &mut fidl::encoding::Encoder<
4484                '_,
4485                fidl::encoding::DefaultFuchsiaResourceDialect,
4486            >,
4487            offset: usize,
4488            mut depth: fidl::encoding::Depth,
4489        ) -> fidl::Result<()> {
4490            encoder.debug_check_bounds::<PuppetEmbedRemoteViewResponse>(offset);
4491            // Vector header
4492            let max_ordinal: u64 = self.max_ordinal_present();
4493            encoder.write_num(max_ordinal, offset);
4494            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4495            // Calling encoder.out_of_line_offset(0) is not allowed.
4496            if max_ordinal == 0 {
4497                return Ok(());
4498            }
4499            depth.increment()?;
4500            let envelope_size = 8;
4501            let bytes_len = max_ordinal as usize * envelope_size;
4502            #[allow(unused_variables)]
4503            let offset = encoder.out_of_line_offset(bytes_len);
4504            let mut _prev_end_offset: usize = 0;
4505            if 1 > max_ordinal {
4506                return Ok(());
4507            }
4508
4509            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4510            // are envelope_size bytes.
4511            let cur_offset: usize = (1 - 1) * envelope_size;
4512
4513            // Zero reserved fields.
4514            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4515
4516            // Safety:
4517            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4518            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4519            //   envelope_size bytes, there is always sufficient room.
4520            fidl::encoding::encode_in_envelope_optional::<
4521                Result_,
4522                fidl::encoding::DefaultFuchsiaResourceDialect,
4523            >(
4524                self.result.as_ref().map(<Result_ as fidl::encoding::ValueTypeMarker>::borrow),
4525                encoder,
4526                offset + cur_offset,
4527                depth,
4528            )?;
4529
4530            _prev_end_offset = cur_offset + envelope_size;
4531            if 2 > max_ordinal {
4532                return Ok(());
4533            }
4534
4535            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4536            // are envelope_size bytes.
4537            let cur_offset: usize = (2 - 1) * envelope_size;
4538
4539            // Zero reserved fields.
4540            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4541
4542            // Safety:
4543            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4544            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4545            //   envelope_size bytes, there is always sufficient room.
4546            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_ui_views::ViewCreationToken, fidl::encoding::DefaultFuchsiaResourceDialect>(
4547            self.view_creation_token.as_mut().map(<fidl_fuchsia_ui_views::ViewCreationToken as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
4548            encoder, offset + cur_offset, depth
4549        )?;
4550
4551            _prev_end_offset = cur_offset + envelope_size;
4552
4553            Ok(())
4554        }
4555    }
4556
4557    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
4558        for PuppetEmbedRemoteViewResponse
4559    {
4560        #[inline(always)]
4561        fn new_empty() -> Self {
4562            Self::default()
4563        }
4564
4565        unsafe fn decode(
4566            &mut self,
4567            decoder: &mut fidl::encoding::Decoder<
4568                '_,
4569                fidl::encoding::DefaultFuchsiaResourceDialect,
4570            >,
4571            offset: usize,
4572            mut depth: fidl::encoding::Depth,
4573        ) -> fidl::Result<()> {
4574            decoder.debug_check_bounds::<Self>(offset);
4575            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4576                None => return Err(fidl::Error::NotNullable),
4577                Some(len) => len,
4578            };
4579            // Calling decoder.out_of_line_offset(0) is not allowed.
4580            if len == 0 {
4581                return Ok(());
4582            };
4583            depth.increment()?;
4584            let envelope_size = 8;
4585            let bytes_len = len * envelope_size;
4586            let offset = decoder.out_of_line_offset(bytes_len)?;
4587            // Decode the envelope for each type.
4588            let mut _next_ordinal_to_read = 0;
4589            let mut next_offset = offset;
4590            let end_offset = offset + bytes_len;
4591            _next_ordinal_to_read += 1;
4592            if next_offset >= end_offset {
4593                return Ok(());
4594            }
4595
4596            // Decode unknown envelopes for gaps in ordinals.
4597            while _next_ordinal_to_read < 1 {
4598                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4599                _next_ordinal_to_read += 1;
4600                next_offset += envelope_size;
4601            }
4602
4603            let next_out_of_line = decoder.next_out_of_line();
4604            let handles_before = decoder.remaining_handles();
4605            if let Some((inlined, num_bytes, num_handles)) =
4606                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4607            {
4608                let member_inline_size =
4609                    <Result_ as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4610                if inlined != (member_inline_size <= 4) {
4611                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4612                }
4613                let inner_offset;
4614                let mut inner_depth = depth.clone();
4615                if inlined {
4616                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4617                    inner_offset = next_offset;
4618                } else {
4619                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4620                    inner_depth.increment()?;
4621                }
4622                let val_ref = self.result.get_or_insert_with(|| {
4623                    fidl::new_empty!(Result_, fidl::encoding::DefaultFuchsiaResourceDialect)
4624                });
4625                fidl::decode!(
4626                    Result_,
4627                    fidl::encoding::DefaultFuchsiaResourceDialect,
4628                    val_ref,
4629                    decoder,
4630                    inner_offset,
4631                    inner_depth
4632                )?;
4633                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4634                {
4635                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4636                }
4637                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4638                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4639                }
4640            }
4641
4642            next_offset += envelope_size;
4643            _next_ordinal_to_read += 1;
4644            if next_offset >= end_offset {
4645                return Ok(());
4646            }
4647
4648            // Decode unknown envelopes for gaps in ordinals.
4649            while _next_ordinal_to_read < 2 {
4650                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4651                _next_ordinal_to_read += 1;
4652                next_offset += envelope_size;
4653            }
4654
4655            let next_out_of_line = decoder.next_out_of_line();
4656            let handles_before = decoder.remaining_handles();
4657            if let Some((inlined, num_bytes, num_handles)) =
4658                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4659            {
4660                let member_inline_size = <fidl_fuchsia_ui_views::ViewCreationToken as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4661                if inlined != (member_inline_size <= 4) {
4662                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4663                }
4664                let inner_offset;
4665                let mut inner_depth = depth.clone();
4666                if inlined {
4667                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4668                    inner_offset = next_offset;
4669                } else {
4670                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4671                    inner_depth.increment()?;
4672                }
4673                let val_ref = self.view_creation_token.get_or_insert_with(|| {
4674                    fidl::new_empty!(
4675                        fidl_fuchsia_ui_views::ViewCreationToken,
4676                        fidl::encoding::DefaultFuchsiaResourceDialect
4677                    )
4678                });
4679                fidl::decode!(
4680                    fidl_fuchsia_ui_views::ViewCreationToken,
4681                    fidl::encoding::DefaultFuchsiaResourceDialect,
4682                    val_ref,
4683                    decoder,
4684                    inner_offset,
4685                    inner_depth
4686                )?;
4687                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4688                {
4689                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4690                }
4691                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4692                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4693                }
4694            }
4695
4696            next_offset += envelope_size;
4697
4698            // Decode the remaining unknown envelopes.
4699            while next_offset < end_offset {
4700                _next_ordinal_to_read += 1;
4701                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4702                next_offset += envelope_size;
4703            }
4704
4705            Ok(())
4706        }
4707    }
4708
4709    impl PuppetFactoryCreateResponse {
4710        #[inline(always)]
4711        fn max_ordinal_present(&self) -> u64 {
4712            if let Some(_) = self.view_ref {
4713                return 2;
4714            }
4715            if let Some(_) = self.result {
4716                return 1;
4717            }
4718            0
4719        }
4720    }
4721
4722    impl fidl::encoding::ResourceTypeMarker for PuppetFactoryCreateResponse {
4723        type Borrowed<'a> = &'a mut Self;
4724        fn take_or_borrow<'a>(
4725            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
4726        ) -> Self::Borrowed<'a> {
4727            value
4728        }
4729    }
4730
4731    unsafe impl fidl::encoding::TypeMarker for PuppetFactoryCreateResponse {
4732        type Owned = Self;
4733
4734        #[inline(always)]
4735        fn inline_align(_context: fidl::encoding::Context) -> usize {
4736            8
4737        }
4738
4739        #[inline(always)]
4740        fn inline_size(_context: fidl::encoding::Context) -> usize {
4741            16
4742        }
4743    }
4744
4745    unsafe impl
4746        fidl::encoding::Encode<
4747            PuppetFactoryCreateResponse,
4748            fidl::encoding::DefaultFuchsiaResourceDialect,
4749        > for &mut PuppetFactoryCreateResponse
4750    {
4751        unsafe fn encode(
4752            self,
4753            encoder: &mut fidl::encoding::Encoder<
4754                '_,
4755                fidl::encoding::DefaultFuchsiaResourceDialect,
4756            >,
4757            offset: usize,
4758            mut depth: fidl::encoding::Depth,
4759        ) -> fidl::Result<()> {
4760            encoder.debug_check_bounds::<PuppetFactoryCreateResponse>(offset);
4761            // Vector header
4762            let max_ordinal: u64 = self.max_ordinal_present();
4763            encoder.write_num(max_ordinal, offset);
4764            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4765            // Calling encoder.out_of_line_offset(0) is not allowed.
4766            if max_ordinal == 0 {
4767                return Ok(());
4768            }
4769            depth.increment()?;
4770            let envelope_size = 8;
4771            let bytes_len = max_ordinal as usize * envelope_size;
4772            #[allow(unused_variables)]
4773            let offset = encoder.out_of_line_offset(bytes_len);
4774            let mut _prev_end_offset: usize = 0;
4775            if 1 > max_ordinal {
4776                return Ok(());
4777            }
4778
4779            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4780            // are envelope_size bytes.
4781            let cur_offset: usize = (1 - 1) * envelope_size;
4782
4783            // Zero reserved fields.
4784            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4785
4786            // Safety:
4787            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4788            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4789            //   envelope_size bytes, there is always sufficient room.
4790            fidl::encoding::encode_in_envelope_optional::<
4791                Result_,
4792                fidl::encoding::DefaultFuchsiaResourceDialect,
4793            >(
4794                self.result.as_ref().map(<Result_ as fidl::encoding::ValueTypeMarker>::borrow),
4795                encoder,
4796                offset + cur_offset,
4797                depth,
4798            )?;
4799
4800            _prev_end_offset = cur_offset + envelope_size;
4801            if 2 > max_ordinal {
4802                return Ok(());
4803            }
4804
4805            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4806            // are envelope_size bytes.
4807            let cur_offset: usize = (2 - 1) * envelope_size;
4808
4809            // Zero reserved fields.
4810            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4811
4812            // Safety:
4813            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4814            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4815            //   envelope_size bytes, there is always sufficient room.
4816            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_ui_views::ViewRef, fidl::encoding::DefaultFuchsiaResourceDialect>(
4817            self.view_ref.as_mut().map(<fidl_fuchsia_ui_views::ViewRef as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
4818            encoder, offset + cur_offset, depth
4819        )?;
4820
4821            _prev_end_offset = cur_offset + envelope_size;
4822
4823            Ok(())
4824        }
4825    }
4826
4827    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
4828        for PuppetFactoryCreateResponse
4829    {
4830        #[inline(always)]
4831        fn new_empty() -> Self {
4832            Self::default()
4833        }
4834
4835        unsafe fn decode(
4836            &mut self,
4837            decoder: &mut fidl::encoding::Decoder<
4838                '_,
4839                fidl::encoding::DefaultFuchsiaResourceDialect,
4840            >,
4841            offset: usize,
4842            mut depth: fidl::encoding::Depth,
4843        ) -> fidl::Result<()> {
4844            decoder.debug_check_bounds::<Self>(offset);
4845            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4846                None => return Err(fidl::Error::NotNullable),
4847                Some(len) => len,
4848            };
4849            // Calling decoder.out_of_line_offset(0) is not allowed.
4850            if len == 0 {
4851                return Ok(());
4852            };
4853            depth.increment()?;
4854            let envelope_size = 8;
4855            let bytes_len = len * envelope_size;
4856            let offset = decoder.out_of_line_offset(bytes_len)?;
4857            // Decode the envelope for each type.
4858            let mut _next_ordinal_to_read = 0;
4859            let mut next_offset = offset;
4860            let end_offset = offset + bytes_len;
4861            _next_ordinal_to_read += 1;
4862            if next_offset >= end_offset {
4863                return Ok(());
4864            }
4865
4866            // Decode unknown envelopes for gaps in ordinals.
4867            while _next_ordinal_to_read < 1 {
4868                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4869                _next_ordinal_to_read += 1;
4870                next_offset += envelope_size;
4871            }
4872
4873            let next_out_of_line = decoder.next_out_of_line();
4874            let handles_before = decoder.remaining_handles();
4875            if let Some((inlined, num_bytes, num_handles)) =
4876                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4877            {
4878                let member_inline_size =
4879                    <Result_ as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4880                if inlined != (member_inline_size <= 4) {
4881                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4882                }
4883                let inner_offset;
4884                let mut inner_depth = depth.clone();
4885                if inlined {
4886                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4887                    inner_offset = next_offset;
4888                } else {
4889                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4890                    inner_depth.increment()?;
4891                }
4892                let val_ref = self.result.get_or_insert_with(|| {
4893                    fidl::new_empty!(Result_, fidl::encoding::DefaultFuchsiaResourceDialect)
4894                });
4895                fidl::decode!(
4896                    Result_,
4897                    fidl::encoding::DefaultFuchsiaResourceDialect,
4898                    val_ref,
4899                    decoder,
4900                    inner_offset,
4901                    inner_depth
4902                )?;
4903                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4904                {
4905                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4906                }
4907                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4908                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4909                }
4910            }
4911
4912            next_offset += envelope_size;
4913            _next_ordinal_to_read += 1;
4914            if next_offset >= end_offset {
4915                return Ok(());
4916            }
4917
4918            // Decode unknown envelopes for gaps in ordinals.
4919            while _next_ordinal_to_read < 2 {
4920                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4921                _next_ordinal_to_read += 1;
4922                next_offset += envelope_size;
4923            }
4924
4925            let next_out_of_line = decoder.next_out_of_line();
4926            let handles_before = decoder.remaining_handles();
4927            if let Some((inlined, num_bytes, num_handles)) =
4928                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4929            {
4930                let member_inline_size =
4931                    <fidl_fuchsia_ui_views::ViewRef as fidl::encoding::TypeMarker>::inline_size(
4932                        decoder.context,
4933                    );
4934                if inlined != (member_inline_size <= 4) {
4935                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4936                }
4937                let inner_offset;
4938                let mut inner_depth = depth.clone();
4939                if inlined {
4940                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4941                    inner_offset = next_offset;
4942                } else {
4943                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4944                    inner_depth.increment()?;
4945                }
4946                let val_ref = self.view_ref.get_or_insert_with(|| {
4947                    fidl::new_empty!(
4948                        fidl_fuchsia_ui_views::ViewRef,
4949                        fidl::encoding::DefaultFuchsiaResourceDialect
4950                    )
4951                });
4952                fidl::decode!(
4953                    fidl_fuchsia_ui_views::ViewRef,
4954                    fidl::encoding::DefaultFuchsiaResourceDialect,
4955                    val_ref,
4956                    decoder,
4957                    inner_offset,
4958                    inner_depth
4959                )?;
4960                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4961                {
4962                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4963                }
4964                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4965                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4966                }
4967            }
4968
4969            next_offset += envelope_size;
4970
4971            // Decode the remaining unknown envelopes.
4972            while next_offset < end_offset {
4973                _next_ordinal_to_read += 1;
4974                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4975                next_offset += envelope_size;
4976            }
4977
4978            Ok(())
4979        }
4980    }
4981
4982    impl PuppetSetEmbeddedViewPropertiesRequest {
4983        #[inline(always)]
4984        fn max_ordinal_present(&self) -> u64 {
4985            if let Some(_) = self.properties {
4986                return 2;
4987            }
4988            if let Some(_) = self.id {
4989                return 1;
4990            }
4991            0
4992        }
4993    }
4994
4995    impl fidl::encoding::ValueTypeMarker for PuppetSetEmbeddedViewPropertiesRequest {
4996        type Borrowed<'a> = &'a Self;
4997        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4998            value
4999        }
5000    }
5001
5002    unsafe impl fidl::encoding::TypeMarker for PuppetSetEmbeddedViewPropertiesRequest {
5003        type Owned = Self;
5004
5005        #[inline(always)]
5006        fn inline_align(_context: fidl::encoding::Context) -> usize {
5007            8
5008        }
5009
5010        #[inline(always)]
5011        fn inline_size(_context: fidl::encoding::Context) -> usize {
5012            16
5013        }
5014    }
5015
5016    unsafe impl<D: fidl::encoding::ResourceDialect>
5017        fidl::encoding::Encode<PuppetSetEmbeddedViewPropertiesRequest, D>
5018        for &PuppetSetEmbeddedViewPropertiesRequest
5019    {
5020        unsafe fn encode(
5021            self,
5022            encoder: &mut fidl::encoding::Encoder<'_, D>,
5023            offset: usize,
5024            mut depth: fidl::encoding::Depth,
5025        ) -> fidl::Result<()> {
5026            encoder.debug_check_bounds::<PuppetSetEmbeddedViewPropertiesRequest>(offset);
5027            // Vector header
5028            let max_ordinal: u64 = self.max_ordinal_present();
5029            encoder.write_num(max_ordinal, offset);
5030            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5031            // Calling encoder.out_of_line_offset(0) is not allowed.
5032            if max_ordinal == 0 {
5033                return Ok(());
5034            }
5035            depth.increment()?;
5036            let envelope_size = 8;
5037            let bytes_len = max_ordinal as usize * envelope_size;
5038            #[allow(unused_variables)]
5039            let offset = encoder.out_of_line_offset(bytes_len);
5040            let mut _prev_end_offset: usize = 0;
5041            if 1 > max_ordinal {
5042                return Ok(());
5043            }
5044
5045            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5046            // are envelope_size bytes.
5047            let cur_offset: usize = (1 - 1) * envelope_size;
5048
5049            // Zero reserved fields.
5050            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5051
5052            // Safety:
5053            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5054            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5055            //   envelope_size bytes, there is always sufficient room.
5056            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5057                self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5058                encoder,
5059                offset + cur_offset,
5060                depth,
5061            )?;
5062
5063            _prev_end_offset = cur_offset + envelope_size;
5064            if 2 > max_ordinal {
5065                return Ok(());
5066            }
5067
5068            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5069            // are envelope_size bytes.
5070            let cur_offset: usize = (2 - 1) * envelope_size;
5071
5072            // Zero reserved fields.
5073            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5074
5075            // Safety:
5076            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5077            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5078            //   envelope_size bytes, there is always sufficient room.
5079            fidl::encoding::encode_in_envelope_optional::<EmbeddedViewProperties, D>(
5080                self.properties
5081                    .as_ref()
5082                    .map(<EmbeddedViewProperties as fidl::encoding::ValueTypeMarker>::borrow),
5083                encoder,
5084                offset + cur_offset,
5085                depth,
5086            )?;
5087
5088            _prev_end_offset = cur_offset + envelope_size;
5089
5090            Ok(())
5091        }
5092    }
5093
5094    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5095        for PuppetSetEmbeddedViewPropertiesRequest
5096    {
5097        #[inline(always)]
5098        fn new_empty() -> Self {
5099            Self::default()
5100        }
5101
5102        unsafe fn decode(
5103            &mut self,
5104            decoder: &mut fidl::encoding::Decoder<'_, D>,
5105            offset: usize,
5106            mut depth: fidl::encoding::Depth,
5107        ) -> fidl::Result<()> {
5108            decoder.debug_check_bounds::<Self>(offset);
5109            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5110                None => return Err(fidl::Error::NotNullable),
5111                Some(len) => len,
5112            };
5113            // Calling decoder.out_of_line_offset(0) is not allowed.
5114            if len == 0 {
5115                return Ok(());
5116            };
5117            depth.increment()?;
5118            let envelope_size = 8;
5119            let bytes_len = len * envelope_size;
5120            let offset = decoder.out_of_line_offset(bytes_len)?;
5121            // Decode the envelope for each type.
5122            let mut _next_ordinal_to_read = 0;
5123            let mut next_offset = offset;
5124            let end_offset = offset + bytes_len;
5125            _next_ordinal_to_read += 1;
5126            if next_offset >= end_offset {
5127                return Ok(());
5128            }
5129
5130            // Decode unknown envelopes for gaps in ordinals.
5131            while _next_ordinal_to_read < 1 {
5132                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5133                _next_ordinal_to_read += 1;
5134                next_offset += envelope_size;
5135            }
5136
5137            let next_out_of_line = decoder.next_out_of_line();
5138            let handles_before = decoder.remaining_handles();
5139            if let Some((inlined, num_bytes, num_handles)) =
5140                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5141            {
5142                let member_inline_size =
5143                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5144                if inlined != (member_inline_size <= 4) {
5145                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5146                }
5147                let inner_offset;
5148                let mut inner_depth = depth.clone();
5149                if inlined {
5150                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5151                    inner_offset = next_offset;
5152                } else {
5153                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5154                    inner_depth.increment()?;
5155                }
5156                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
5157                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5158                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5159                {
5160                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5161                }
5162                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5163                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5164                }
5165            }
5166
5167            next_offset += envelope_size;
5168            _next_ordinal_to_read += 1;
5169            if next_offset >= end_offset {
5170                return Ok(());
5171            }
5172
5173            // Decode unknown envelopes for gaps in ordinals.
5174            while _next_ordinal_to_read < 2 {
5175                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5176                _next_ordinal_to_read += 1;
5177                next_offset += envelope_size;
5178            }
5179
5180            let next_out_of_line = decoder.next_out_of_line();
5181            let handles_before = decoder.remaining_handles();
5182            if let Some((inlined, num_bytes, num_handles)) =
5183                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5184            {
5185                let member_inline_size =
5186                    <EmbeddedViewProperties as fidl::encoding::TypeMarker>::inline_size(
5187                        decoder.context,
5188                    );
5189                if inlined != (member_inline_size <= 4) {
5190                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5191                }
5192                let inner_offset;
5193                let mut inner_depth = depth.clone();
5194                if inlined {
5195                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5196                    inner_offset = next_offset;
5197                } else {
5198                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5199                    inner_depth.increment()?;
5200                }
5201                let val_ref = self
5202                    .properties
5203                    .get_or_insert_with(|| fidl::new_empty!(EmbeddedViewProperties, D));
5204                fidl::decode!(
5205                    EmbeddedViewProperties,
5206                    D,
5207                    val_ref,
5208                    decoder,
5209                    inner_offset,
5210                    inner_depth
5211                )?;
5212                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5213                {
5214                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5215                }
5216                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5217                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5218                }
5219            }
5220
5221            next_offset += envelope_size;
5222
5223            // Decode the remaining unknown envelopes.
5224            while next_offset < end_offset {
5225                _next_ordinal_to_read += 1;
5226                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5227                next_offset += envelope_size;
5228            }
5229
5230            Ok(())
5231        }
5232    }
5233
5234    impl PuppetSetEmbeddedViewPropertiesResponse {
5235        #[inline(always)]
5236        fn max_ordinal_present(&self) -> u64 {
5237            if let Some(_) = self.result {
5238                return 1;
5239            }
5240            0
5241        }
5242    }
5243
5244    impl fidl::encoding::ValueTypeMarker for PuppetSetEmbeddedViewPropertiesResponse {
5245        type Borrowed<'a> = &'a Self;
5246        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5247            value
5248        }
5249    }
5250
5251    unsafe impl fidl::encoding::TypeMarker for PuppetSetEmbeddedViewPropertiesResponse {
5252        type Owned = Self;
5253
5254        #[inline(always)]
5255        fn inline_align(_context: fidl::encoding::Context) -> usize {
5256            8
5257        }
5258
5259        #[inline(always)]
5260        fn inline_size(_context: fidl::encoding::Context) -> usize {
5261            16
5262        }
5263    }
5264
5265    unsafe impl<D: fidl::encoding::ResourceDialect>
5266        fidl::encoding::Encode<PuppetSetEmbeddedViewPropertiesResponse, D>
5267        for &PuppetSetEmbeddedViewPropertiesResponse
5268    {
5269        unsafe fn encode(
5270            self,
5271            encoder: &mut fidl::encoding::Encoder<'_, D>,
5272            offset: usize,
5273            mut depth: fidl::encoding::Depth,
5274        ) -> fidl::Result<()> {
5275            encoder.debug_check_bounds::<PuppetSetEmbeddedViewPropertiesResponse>(offset);
5276            // Vector header
5277            let max_ordinal: u64 = self.max_ordinal_present();
5278            encoder.write_num(max_ordinal, offset);
5279            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5280            // Calling encoder.out_of_line_offset(0) is not allowed.
5281            if max_ordinal == 0 {
5282                return Ok(());
5283            }
5284            depth.increment()?;
5285            let envelope_size = 8;
5286            let bytes_len = max_ordinal as usize * envelope_size;
5287            #[allow(unused_variables)]
5288            let offset = encoder.out_of_line_offset(bytes_len);
5289            let mut _prev_end_offset: usize = 0;
5290            if 1 > max_ordinal {
5291                return Ok(());
5292            }
5293
5294            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5295            // are envelope_size bytes.
5296            let cur_offset: usize = (1 - 1) * envelope_size;
5297
5298            // Zero reserved fields.
5299            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5300
5301            // Safety:
5302            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5303            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5304            //   envelope_size bytes, there is always sufficient room.
5305            fidl::encoding::encode_in_envelope_optional::<Result_, D>(
5306                self.result.as_ref().map(<Result_ as fidl::encoding::ValueTypeMarker>::borrow),
5307                encoder,
5308                offset + cur_offset,
5309                depth,
5310            )?;
5311
5312            _prev_end_offset = cur_offset + envelope_size;
5313
5314            Ok(())
5315        }
5316    }
5317
5318    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5319        for PuppetSetEmbeddedViewPropertiesResponse
5320    {
5321        #[inline(always)]
5322        fn new_empty() -> Self {
5323            Self::default()
5324        }
5325
5326        unsafe fn decode(
5327            &mut self,
5328            decoder: &mut fidl::encoding::Decoder<'_, D>,
5329            offset: usize,
5330            mut depth: fidl::encoding::Depth,
5331        ) -> fidl::Result<()> {
5332            decoder.debug_check_bounds::<Self>(offset);
5333            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5334                None => return Err(fidl::Error::NotNullable),
5335                Some(len) => len,
5336            };
5337            // Calling decoder.out_of_line_offset(0) is not allowed.
5338            if len == 0 {
5339                return Ok(());
5340            };
5341            depth.increment()?;
5342            let envelope_size = 8;
5343            let bytes_len = len * envelope_size;
5344            let offset = decoder.out_of_line_offset(bytes_len)?;
5345            // Decode the envelope for each type.
5346            let mut _next_ordinal_to_read = 0;
5347            let mut next_offset = offset;
5348            let end_offset = offset + bytes_len;
5349            _next_ordinal_to_read += 1;
5350            if next_offset >= end_offset {
5351                return Ok(());
5352            }
5353
5354            // Decode unknown envelopes for gaps in ordinals.
5355            while _next_ordinal_to_read < 1 {
5356                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5357                _next_ordinal_to_read += 1;
5358                next_offset += envelope_size;
5359            }
5360
5361            let next_out_of_line = decoder.next_out_of_line();
5362            let handles_before = decoder.remaining_handles();
5363            if let Some((inlined, num_bytes, num_handles)) =
5364                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5365            {
5366                let member_inline_size =
5367                    <Result_ as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5368                if inlined != (member_inline_size <= 4) {
5369                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5370                }
5371                let inner_offset;
5372                let mut inner_depth = depth.clone();
5373                if inlined {
5374                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5375                    inner_offset = next_offset;
5376                } else {
5377                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5378                    inner_depth.increment()?;
5379                }
5380                let val_ref = self.result.get_or_insert_with(|| fidl::new_empty!(Result_, D));
5381                fidl::decode!(Result_, D, val_ref, decoder, inner_offset, inner_depth)?;
5382                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5383                {
5384                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5385                }
5386                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5387                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5388                }
5389            }
5390
5391            next_offset += envelope_size;
5392
5393            // Decode the remaining unknown envelopes.
5394            while next_offset < end_offset {
5395                _next_ordinal_to_read += 1;
5396                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5397                next_offset += envelope_size;
5398            }
5399
5400            Ok(())
5401        }
5402    }
5403
5404    impl PuppetSetImagePropertiesRequest {
5405        #[inline(always)]
5406        fn max_ordinal_present(&self) -> u64 {
5407            if let Some(_) = self.properties {
5408                return 2;
5409            }
5410            if let Some(_) = self.id {
5411                return 1;
5412            }
5413            0
5414        }
5415    }
5416
5417    impl fidl::encoding::ValueTypeMarker for PuppetSetImagePropertiesRequest {
5418        type Borrowed<'a> = &'a Self;
5419        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5420            value
5421        }
5422    }
5423
5424    unsafe impl fidl::encoding::TypeMarker for PuppetSetImagePropertiesRequest {
5425        type Owned = Self;
5426
5427        #[inline(always)]
5428        fn inline_align(_context: fidl::encoding::Context) -> usize {
5429            8
5430        }
5431
5432        #[inline(always)]
5433        fn inline_size(_context: fidl::encoding::Context) -> usize {
5434            16
5435        }
5436    }
5437
5438    unsafe impl<D: fidl::encoding::ResourceDialect>
5439        fidl::encoding::Encode<PuppetSetImagePropertiesRequest, D>
5440        for &PuppetSetImagePropertiesRequest
5441    {
5442        unsafe fn encode(
5443            self,
5444            encoder: &mut fidl::encoding::Encoder<'_, D>,
5445            offset: usize,
5446            mut depth: fidl::encoding::Depth,
5447        ) -> fidl::Result<()> {
5448            encoder.debug_check_bounds::<PuppetSetImagePropertiesRequest>(offset);
5449            // Vector header
5450            let max_ordinal: u64 = self.max_ordinal_present();
5451            encoder.write_num(max_ordinal, offset);
5452            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5453            // Calling encoder.out_of_line_offset(0) is not allowed.
5454            if max_ordinal == 0 {
5455                return Ok(());
5456            }
5457            depth.increment()?;
5458            let envelope_size = 8;
5459            let bytes_len = max_ordinal as usize * envelope_size;
5460            #[allow(unused_variables)]
5461            let offset = encoder.out_of_line_offset(bytes_len);
5462            let mut _prev_end_offset: usize = 0;
5463            if 1 > max_ordinal {
5464                return Ok(());
5465            }
5466
5467            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5468            // are envelope_size bytes.
5469            let cur_offset: usize = (1 - 1) * envelope_size;
5470
5471            // Zero reserved fields.
5472            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5473
5474            // Safety:
5475            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5476            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5477            //   envelope_size bytes, there is always sufficient room.
5478            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5479                self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5480                encoder,
5481                offset + cur_offset,
5482                depth,
5483            )?;
5484
5485            _prev_end_offset = cur_offset + envelope_size;
5486            if 2 > max_ordinal {
5487                return Ok(());
5488            }
5489
5490            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5491            // are envelope_size bytes.
5492            let cur_offset: usize = (2 - 1) * envelope_size;
5493
5494            // Zero reserved fields.
5495            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5496
5497            // Safety:
5498            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5499            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5500            //   envelope_size bytes, there is always sufficient room.
5501            fidl::encoding::encode_in_envelope_optional::<ImageProperties, D>(
5502                self.properties
5503                    .as_ref()
5504                    .map(<ImageProperties as fidl::encoding::ValueTypeMarker>::borrow),
5505                encoder,
5506                offset + cur_offset,
5507                depth,
5508            )?;
5509
5510            _prev_end_offset = cur_offset + envelope_size;
5511
5512            Ok(())
5513        }
5514    }
5515
5516    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5517        for PuppetSetImagePropertiesRequest
5518    {
5519        #[inline(always)]
5520        fn new_empty() -> Self {
5521            Self::default()
5522        }
5523
5524        unsafe fn decode(
5525            &mut self,
5526            decoder: &mut fidl::encoding::Decoder<'_, D>,
5527            offset: usize,
5528            mut depth: fidl::encoding::Depth,
5529        ) -> fidl::Result<()> {
5530            decoder.debug_check_bounds::<Self>(offset);
5531            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5532                None => return Err(fidl::Error::NotNullable),
5533                Some(len) => len,
5534            };
5535            // Calling decoder.out_of_line_offset(0) is not allowed.
5536            if len == 0 {
5537                return Ok(());
5538            };
5539            depth.increment()?;
5540            let envelope_size = 8;
5541            let bytes_len = len * envelope_size;
5542            let offset = decoder.out_of_line_offset(bytes_len)?;
5543            // Decode the envelope for each type.
5544            let mut _next_ordinal_to_read = 0;
5545            let mut next_offset = offset;
5546            let end_offset = offset + bytes_len;
5547            _next_ordinal_to_read += 1;
5548            if next_offset >= end_offset {
5549                return Ok(());
5550            }
5551
5552            // Decode unknown envelopes for gaps in ordinals.
5553            while _next_ordinal_to_read < 1 {
5554                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5555                _next_ordinal_to_read += 1;
5556                next_offset += envelope_size;
5557            }
5558
5559            let next_out_of_line = decoder.next_out_of_line();
5560            let handles_before = decoder.remaining_handles();
5561            if let Some((inlined, num_bytes, num_handles)) =
5562                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5563            {
5564                let member_inline_size =
5565                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5566                if inlined != (member_inline_size <= 4) {
5567                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5568                }
5569                let inner_offset;
5570                let mut inner_depth = depth.clone();
5571                if inlined {
5572                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5573                    inner_offset = next_offset;
5574                } else {
5575                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5576                    inner_depth.increment()?;
5577                }
5578                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
5579                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5580                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5581                {
5582                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5583                }
5584                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5585                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5586                }
5587            }
5588
5589            next_offset += envelope_size;
5590            _next_ordinal_to_read += 1;
5591            if next_offset >= end_offset {
5592                return Ok(());
5593            }
5594
5595            // Decode unknown envelopes for gaps in ordinals.
5596            while _next_ordinal_to_read < 2 {
5597                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5598                _next_ordinal_to_read += 1;
5599                next_offset += envelope_size;
5600            }
5601
5602            let next_out_of_line = decoder.next_out_of_line();
5603            let handles_before = decoder.remaining_handles();
5604            if let Some((inlined, num_bytes, num_handles)) =
5605                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5606            {
5607                let member_inline_size =
5608                    <ImageProperties as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5609                if inlined != (member_inline_size <= 4) {
5610                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5611                }
5612                let inner_offset;
5613                let mut inner_depth = depth.clone();
5614                if inlined {
5615                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5616                    inner_offset = next_offset;
5617                } else {
5618                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5619                    inner_depth.increment()?;
5620                }
5621                let val_ref =
5622                    self.properties.get_or_insert_with(|| fidl::new_empty!(ImageProperties, D));
5623                fidl::decode!(ImageProperties, D, val_ref, decoder, inner_offset, inner_depth)?;
5624                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5625                {
5626                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5627                }
5628                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5629                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5630                }
5631            }
5632
5633            next_offset += envelope_size;
5634
5635            // Decode the remaining unknown envelopes.
5636            while next_offset < end_offset {
5637                _next_ordinal_to_read += 1;
5638                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5639                next_offset += envelope_size;
5640            }
5641
5642            Ok(())
5643        }
5644    }
5645
5646    impl PuppetSetImagePropertiesResponse {
5647        #[inline(always)]
5648        fn max_ordinal_present(&self) -> u64 {
5649            if let Some(_) = self.result {
5650                return 1;
5651            }
5652            0
5653        }
5654    }
5655
5656    impl fidl::encoding::ValueTypeMarker for PuppetSetImagePropertiesResponse {
5657        type Borrowed<'a> = &'a Self;
5658        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5659            value
5660        }
5661    }
5662
5663    unsafe impl fidl::encoding::TypeMarker for PuppetSetImagePropertiesResponse {
5664        type Owned = Self;
5665
5666        #[inline(always)]
5667        fn inline_align(_context: fidl::encoding::Context) -> usize {
5668            8
5669        }
5670
5671        #[inline(always)]
5672        fn inline_size(_context: fidl::encoding::Context) -> usize {
5673            16
5674        }
5675    }
5676
5677    unsafe impl<D: fidl::encoding::ResourceDialect>
5678        fidl::encoding::Encode<PuppetSetImagePropertiesResponse, D>
5679        for &PuppetSetImagePropertiesResponse
5680    {
5681        unsafe fn encode(
5682            self,
5683            encoder: &mut fidl::encoding::Encoder<'_, D>,
5684            offset: usize,
5685            mut depth: fidl::encoding::Depth,
5686        ) -> fidl::Result<()> {
5687            encoder.debug_check_bounds::<PuppetSetImagePropertiesResponse>(offset);
5688            // Vector header
5689            let max_ordinal: u64 = self.max_ordinal_present();
5690            encoder.write_num(max_ordinal, offset);
5691            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5692            // Calling encoder.out_of_line_offset(0) is not allowed.
5693            if max_ordinal == 0 {
5694                return Ok(());
5695            }
5696            depth.increment()?;
5697            let envelope_size = 8;
5698            let bytes_len = max_ordinal as usize * envelope_size;
5699            #[allow(unused_variables)]
5700            let offset = encoder.out_of_line_offset(bytes_len);
5701            let mut _prev_end_offset: usize = 0;
5702            if 1 > max_ordinal {
5703                return Ok(());
5704            }
5705
5706            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5707            // are envelope_size bytes.
5708            let cur_offset: usize = (1 - 1) * envelope_size;
5709
5710            // Zero reserved fields.
5711            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5712
5713            // Safety:
5714            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5715            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5716            //   envelope_size bytes, there is always sufficient room.
5717            fidl::encoding::encode_in_envelope_optional::<Result_, D>(
5718                self.result.as_ref().map(<Result_ as fidl::encoding::ValueTypeMarker>::borrow),
5719                encoder,
5720                offset + cur_offset,
5721                depth,
5722            )?;
5723
5724            _prev_end_offset = cur_offset + envelope_size;
5725
5726            Ok(())
5727        }
5728    }
5729
5730    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5731        for PuppetSetImagePropertiesResponse
5732    {
5733        #[inline(always)]
5734        fn new_empty() -> Self {
5735            Self::default()
5736        }
5737
5738        unsafe fn decode(
5739            &mut self,
5740            decoder: &mut fidl::encoding::Decoder<'_, D>,
5741            offset: usize,
5742            mut depth: fidl::encoding::Depth,
5743        ) -> fidl::Result<()> {
5744            decoder.debug_check_bounds::<Self>(offset);
5745            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5746                None => return Err(fidl::Error::NotNullable),
5747                Some(len) => len,
5748            };
5749            // Calling decoder.out_of_line_offset(0) is not allowed.
5750            if len == 0 {
5751                return Ok(());
5752            };
5753            depth.increment()?;
5754            let envelope_size = 8;
5755            let bytes_len = len * envelope_size;
5756            let offset = decoder.out_of_line_offset(bytes_len)?;
5757            // Decode the envelope for each type.
5758            let mut _next_ordinal_to_read = 0;
5759            let mut next_offset = offset;
5760            let end_offset = offset + bytes_len;
5761            _next_ordinal_to_read += 1;
5762            if next_offset >= end_offset {
5763                return Ok(());
5764            }
5765
5766            // Decode unknown envelopes for gaps in ordinals.
5767            while _next_ordinal_to_read < 1 {
5768                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5769                _next_ordinal_to_read += 1;
5770                next_offset += envelope_size;
5771            }
5772
5773            let next_out_of_line = decoder.next_out_of_line();
5774            let handles_before = decoder.remaining_handles();
5775            if let Some((inlined, num_bytes, num_handles)) =
5776                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5777            {
5778                let member_inline_size =
5779                    <Result_ as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5780                if inlined != (member_inline_size <= 4) {
5781                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5782                }
5783                let inner_offset;
5784                let mut inner_depth = depth.clone();
5785                if inlined {
5786                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5787                    inner_offset = next_offset;
5788                } else {
5789                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5790                    inner_depth.increment()?;
5791                }
5792                let val_ref = self.result.get_or_insert_with(|| fidl::new_empty!(Result_, D));
5793                fidl::decode!(Result_, D, val_ref, decoder, inner_offset, inner_depth)?;
5794                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5795                {
5796                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5797                }
5798                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5799                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5800                }
5801            }
5802
5803            next_offset += envelope_size;
5804
5805            // Decode the remaining unknown envelopes.
5806            while next_offset < end_offset {
5807                _next_ordinal_to_read += 1;
5808                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5809                next_offset += envelope_size;
5810            }
5811
5812            Ok(())
5813        }
5814    }
5815}