fidl_test_conformance/

fidl_test_conformance.rs

// WARNING: This file is machine generated by fidlgen.

#![warn(clippy::all)]
#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]

use bitflags::bitflags;
use fidl::client::QueryResponseFut;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use fidl::endpoints::{ControlHandle as _, Responder as _};
pub use fidl_test_conformance_common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct AlternatingHandlesAndFailures {
    pub h1: fidl::NullableHandle,
    pub failure_trigger1: String,
    pub h2: fidl::NullableHandle,
    pub failure_trigger2: String,
    pub h3: fidl::NullableHandle,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for AlternatingHandlesAndFailures
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ArrayOfArrayOfNonnullableHandles {
    pub handles: [[fidl::NullableHandle; 3]; 4],
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for ArrayOfArrayOfNonnullableHandles
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ArrayOfHandles {
    pub a: [fidl::NullableHandle; 3],
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ArrayOfHandles {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ArrayOfNonnullableHandles {
    pub handles: [fidl::NullableHandle; 4],
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ArrayOfNonnullableHandles {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ArrayOfNullableHandles {
    pub handles: [Option<fidl::NullableHandle>; 5],
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ArrayOfNullableHandles {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ArrayOfOptionalHandles {
    pub a: [Option<fidl::NullableHandle>; 3],
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ArrayOfOptionalHandles {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ArrayOfVectorOfEventInStructWithDefaultRights {
    pub h: [Vec<fidl::Event>; 1],
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for ArrayOfVectorOfEventInStructWithDefaultRights
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ArrayOfVectorOfEventInStructWithReducedRights {
    pub h: [Vec<fidl::Event>; 1],
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for ArrayOfVectorOfEventInStructWithReducedRights
{
}

#[derive(Debug, PartialEq)]
pub struct ArrayOfVectorOfEventInTableWithDefaultRightsStruct {
    pub t: ArrayOfVectorOfEventInTableWithDefaultRights,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for ArrayOfVectorOfEventInTableWithDefaultRightsStruct
{
}

#[derive(Debug, PartialEq)]
pub struct ArrayOfVectorOfEventInTableWithReducedRightsStruct {
    pub t: ArrayOfVectorOfEventInTableWithReducedRights,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for ArrayOfVectorOfEventInTableWithReducedRightsStruct
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ArrayOfVectorOfEventInUnionWithDefaultRightsStruct {
    pub u: ArrayOfVectorOfEventInUnionWithDefaultRights,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for ArrayOfVectorOfEventInUnionWithDefaultRightsStruct
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ArrayOfVectorOfEventInUnionWithReducedRightsStruct {
    pub u: ArrayOfVectorOfEventInUnionWithReducedRights,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for ArrayOfVectorOfEventInUnionWithReducedRightsStruct
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Bounded32NonnullableVectorOfHandles {
    pub vh0: Vec<fidl::NullableHandle>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for Bounded32NonnullableVectorOfHandles
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Bounded32NullableVectorOfHandles {
    pub vh0: Option<Vec<fidl::NullableHandle>>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for Bounded32NullableVectorOfHandles
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BoxOfSingleHandle {
    pub b: Option<Box<SingleHandle>>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for BoxOfSingleHandle {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct BoxOfSingleOptionalHandle {
    pub b: Option<Box<SingleOptionalHandle>>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for BoxOfSingleOptionalHandle {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CreateComponentRequest {
    pub launch_info: LaunchInfo,
    pub controller: Option<fidl::endpoints::ServerEnd<ComponentControllerMarker>>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for CreateComponentRequest {}

#[derive(Debug, PartialEq)]
pub struct EmptyResourceTableStruct {
    pub table: EmptyResourceTable,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EmptyResourceTableStruct {}

#[derive(Debug, PartialEq)]
pub struct EnvelopeInliningTestUnionStruct {
    pub u: EnvelopeInliningTestUnion,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for EnvelopeInliningTestUnionStruct
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct EventWithDefaultRights {
    pub h: fidl::Event,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EventWithDefaultRights {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct EventWithReducedRights {
    pub h: fidl::Event,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EventWithReducedRights {}

#[derive(Debug, PartialEq)]
pub struct FidlvizDemo {
    pub f1: u8,
    pub f2: i8,
    pub f3: u16,
    pub f4: u32,
    pub f5: u64,
    pub f6: u8,
    pub f7: u8,
    pub f8: u16,
    pub f9: f32,
    pub f10: f64,
    pub f11: bool,
    pub f12: bool,
    pub f13: String,
    pub f14: Option<String>,
    pub f15: String,
    pub f16: Option<fidl::NullableHandle>,
    pub f17: fidl::NullableHandle,
    pub f18: [u8; 3],
    pub f19: Vec<f64>,
    pub f20: Option<Vec<u8>>,
    pub f21: Vec<u8>,
    pub f22: FidlvizBits,
    pub f23: FidlvizEnum,
    pub f24: FidlvizStruct1,
    pub f25: FidlvizStruct2,
    pub f26: Option<Box<FidlvizStruct1>>,
    pub f27: Option<Box<FidlvizStruct2>>,
    pub f28: FidlvizTable,
    pub f29: FidlvizTable,
    pub f30: Option<Box<FidlvizUnion>>,
    pub f31: FidlvizUnion,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for FidlvizDemo {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct GoldenHandleBasicRightsStruct {
    pub v: fidl::Event,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for GoldenHandleBasicRightsStruct
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct GoldenNullableHandleStruct {
    pub v: Option<fidl::NullableHandle>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for GoldenNullableHandleStruct
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct LaunchInfo {
    pub url: String,
    pub arguments: Option<Vec<String>>,
    pub out: Option<Box<TransformerEmptyStruct>>,
    pub err: Option<Box<TransformerEmptyStruct>>,
    pub directory_request: Option<fidl::Channel>,
    pub flat_namespace: Option<Box<TransformerEmptyStruct>>,
    pub additional_services: Option<Box<TransformerEmptyStruct>>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for LaunchInfo {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MultipleBoundedNonnullableVectorsOfHandles {
    pub vh0: Vec<fidl::NullableHandle>,
    pub vh1: Vec<fidl::NullableHandle>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for MultipleBoundedNonnullableVectorsOfHandles
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MultipleBoundedNullableVectorsOfHandles {
    pub vh0: Option<Vec<fidl::NullableHandle>>,
    pub vh1: Option<Vec<fidl::NullableHandle>>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for MultipleBoundedNullableVectorsOfHandles
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MultipleHandleSubtypes {
    pub untyped: fidl::NullableHandle,
    pub event: fidl::Event,
    pub channel: fidl::Channel,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for MultipleHandleSubtypes {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MultipleNonnullableHandles {
    pub data0: u32,
    pub handle0: fidl::NullableHandle,
    pub data1: u64,
    pub handle1: fidl::Channel,
    pub handle2: fidl::Event,
    pub data2: u64,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for MultipleNonnullableHandles
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct MultipleNullableHandles {
    pub data0: u32,
    pub handle0: Option<fidl::NullableHandle>,
    pub data1: u64,
    pub handle1: Option<fidl::Channel>,
    pub handle2: Option<fidl::Event>,
    pub data2: u64,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for MultipleNullableHandles {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NonnullableHandle {
    pub h: fidl::NullableHandle,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for NonnullableHandle {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NonnullableHandleArray {
    pub handles: [fidl::NullableHandle; 4],
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for NonnullableHandleArray {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NullableHandle {
    pub h: Option<fidl::NullableHandle>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for NullableHandle {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct OutOfLineArrayOfNonnullableHandles {
    pub handles: Option<Box<NonnullableHandleArray>>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for OutOfLineArrayOfNonnullableHandles
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Sandwich6 {
    pub before: u32,
    pub the_union: UnionWithVector,
    pub after: u32,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Sandwich6 {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ShortStringThenHandle {
    pub s: String,
    pub h: fidl::NullableHandle,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ShortStringThenHandle {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SingleHandle {
    pub h: fidl::NullableHandle,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for SingleHandle {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct SingleOptionalHandle {
    pub h: Option<fidl::NullableHandle>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for SingleOptionalHandle {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct StructOfEndpoints {
    pub client_end: fidl::endpoints::ClientEnd<ProtocolMarker>,
    pub optional_client_end: Option<fidl::endpoints::ClientEnd<ProtocolMarker>>,
    pub server_end: fidl::endpoints::ServerEnd<ProtocolMarker>,
    pub optional_server_end: Option<fidl::endpoints::ServerEnd<ProtocolMarker>>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for StructOfEndpoints {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct StructOfOptionalUnionOfHandle {
    pub u: Option<Box<UnionOfHandle>>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for StructOfOptionalUnionOfHandle
{
}

#[derive(Debug, PartialEq)]
pub struct StructOfSimpleResourceTable {
    pub table: SimpleResourceTable,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for StructOfSimpleResourceTable
{
}

#[derive(Debug, PartialEq)]
pub struct TableFieldInlinedHandleStruct {
    pub t: TableFieldInlinedHandle,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for TableFieldInlinedHandleStruct
{
}

#[derive(Debug, PartialEq)]
pub struct TableFieldUnknownResourceStruct {
    pub t: TableFieldUnknownResource,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for TableFieldUnknownResourceStruct
{
}

#[derive(Debug, PartialEq)]
pub struct TableOfEndpoints {
    pub t: TableOfEndpointsTable,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for TableOfEndpoints {}

#[derive(Debug, PartialEq)]
pub struct TableUnionWithVectorReservedSandwichStruct {
    pub table: TableUnionWithVectorReservedSandwich,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for TableUnionWithVectorReservedSandwichStruct
{
}

#[derive(Debug, PartialEq)]
pub struct TableUnionWithVectorStructSandwichStruct {
    pub table: TableUnionWithVectorStructSandwich,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for TableUnionWithVectorStructSandwichStruct
{
}

#[derive(Debug, PartialEq)]
pub struct TableWithUnknownEnveloepsAfterKnownEnvelopesStruct {
    pub t: TableWithUnknownEnvelopesAfterKnownEnvelopes,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for TableWithUnknownEnveloepsAfterKnownEnvelopesStruct
{
}

#[derive(Debug, PartialEq)]
pub struct TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct {
    pub t: TableWithUnknownEnvelopesBeforeKnownEnvelopes,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct
{
}

#[derive(Debug, PartialEq)]
pub struct TestFlexibleResourceXUnionInStruct {
    pub xu: SampleResourceXUnion,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for TestFlexibleResourceXUnionInStruct
{
}

#[derive(Debug, PartialEq)]
pub struct TestOptionalFlexibleResourceXUnionInStruct {
    pub xu: Option<Box<SampleResourceXUnion>>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for TestOptionalFlexibleResourceXUnionInStruct
{
}

#[derive(Debug, PartialEq)]
pub struct TestOptionalStrictResourceXUnionInStruct {
    pub xu: Option<Box<SampleStrictResourceXUnion>>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for TestOptionalStrictResourceXUnionInStruct
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct TestPackageResolverResolveRequest {
    pub package_url: String,
    pub selectors: Vec<String>,
    pub update_policy: UpdatePolicy,
    pub this_should_be_a_handle: u32,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for TestPackageResolverResolveRequest
{
}

#[derive(Debug, PartialEq)]
pub struct TestStrictResourceXUnionInStruct {
    pub xu: SampleStrictResourceXUnion,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for TestStrictResourceXUnionInStruct
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct UnboundedNonnullableVectorOfHandles {
    pub vh0: Vec<fidl::NullableHandle>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for UnboundedNonnullableVectorOfHandles
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct UnboundedNullableVectorOfHandles {
    pub vh0: Option<Vec<fidl::NullableHandle>>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for UnboundedNullableVectorOfHandles
{
}

#[derive(Debug, PartialEq)]
pub struct UnionOfEndpoints {
    pub u: UnionOfEndpointsUnion,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for UnionOfEndpoints {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct VectorOfArrayOfEventInStructWithDefaultRights {
    pub h: Vec<[fidl::Event; 1]>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for VectorOfArrayOfEventInStructWithDefaultRights
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct VectorOfArrayOfEventInStructWithReducedRights {
    pub h: Vec<[fidl::Event; 1]>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for VectorOfArrayOfEventInStructWithReducedRights
{
}

#[derive(Debug, PartialEq)]
pub struct VectorOfArrayOfEventInTableWithReducedRightsStruct {
    pub t: VectorOfArrayOfEventInTableWithReducedRights,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for VectorOfArrayOfEventInTableWithReducedRightsStruct
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct VectorOfArrayOfEventInUnionWithReducedRightsStruct {
    pub u: VectorOfArrayOfEventInUnionWithReducedRights,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for VectorOfArrayOfEventInUnionWithReducedRightsStruct
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct VectorOfHandles {
    pub v: Vec<fidl::NullableHandle>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for VectorOfHandles {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct VectorOfOptionalHandles {
    pub v: Vec<Option<fidl::NullableHandle>>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for VectorOfOptionalHandles {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct VectorOfUpTo2Handles {
    pub v: Vec<fidl::NullableHandle>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for VectorOfUpTo2Handles {}

#[derive(Debug, Default, PartialEq)]
pub struct ArrayOfVectorOfEventInTableWithDefaultRights {
    pub h: Option<[Vec<fidl::Event>; 1]>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for ArrayOfVectorOfEventInTableWithDefaultRights
{
}

#[derive(Debug, Default, PartialEq)]
pub struct ArrayOfVectorOfEventInTableWithReducedRights {
    pub h: Option<[Vec<fidl::Event>; 1]>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for ArrayOfVectorOfEventInTableWithReducedRights
{
}

#[derive(Debug, Default, PartialEq)]
pub struct EmptyResourceTable {
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EmptyResourceTable {}

#[derive(Debug, Default, PartialEq)]
pub struct SimpleResourceTable {
    pub x: Option<i64>,
    pub y: Option<i64>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for SimpleResourceTable {}

#[derive(Debug, Default, PartialEq)]
pub struct TableFieldInlinedHandle {
    pub f: Option<fidl::Channel>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for TableFieldInlinedHandle {}

#[derive(Debug, Default, PartialEq)]
pub struct TableFieldUnknownResource {
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for TableFieldUnknownResource {}

#[derive(Debug, Default, PartialEq)]
pub struct TableOfEndpointsTable {
    pub client_end: Option<fidl::endpoints::ClientEnd<ProtocolMarker>>,
    pub server_end: Option<fidl::endpoints::ServerEnd<ProtocolMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for TableOfEndpointsTable {}

#[derive(Debug, Default, PartialEq)]
pub struct TableUnionWithVectorReservedSandwich {
    pub uv: Option<UnionWithVector>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for TableUnionWithVectorReservedSandwich
{
}

#[derive(Debug, Default, PartialEq)]
pub struct TableUnionWithVectorStructSandwich {
    pub s1: Option<StructSize3Align1>,
    pub uv: Option<UnionWithVector>,
    pub s2: Option<StructSize3Align1>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for TableUnionWithVectorStructSandwich
{
}

#[derive(Debug, Default, PartialEq)]
pub struct TableWithUnknownEnvelopesAfterKnownEnvelopes {
    pub a: Option<fidl::Event>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for TableWithUnknownEnvelopesAfterKnownEnvelopes
{
}

#[derive(Debug, Default, PartialEq)]
pub struct TableWithUnknownEnvelopesBeforeKnownEnvelopes {
    pub b: Option<fidl::Event>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for TableWithUnknownEnvelopesBeforeKnownEnvelopes
{
}

#[derive(Debug, Default, PartialEq)]
pub struct VectorOfArrayOfEventInTableWithReducedRights {
    pub h: Option<Vec<[fidl::Event; 1]>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for VectorOfArrayOfEventInTableWithReducedRights
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum ArrayOfVectorOfEventInUnionWithDefaultRights {
    H([Vec<fidl::Event>; 1]),
}

impl ArrayOfVectorOfEventInUnionWithDefaultRights {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::H(_) => 1,
        }
    }
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for ArrayOfVectorOfEventInUnionWithDefaultRights
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum ArrayOfVectorOfEventInUnionWithReducedRights {
    H([Vec<fidl::Event>; 1]),
}

impl ArrayOfVectorOfEventInUnionWithReducedRights {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::H(_) => 1,
        }
    }
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for ArrayOfVectorOfEventInUnionWithReducedRights
{
}

#[derive(Debug)]
pub enum EnvelopeInliningTestUnion {
    Small(u32),
    Large(u64),
    Handle(fidl::NullableHandle),
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u64,
    },
}

/// Pattern that matches an unknown `EnvelopeInliningTestUnion` member.
#[macro_export]
macro_rules! EnvelopeInliningTestUnionUnknown {
    () => {
        _
    };
}

// Custom PartialEq so that unknown variants are not equal to themselves.
impl PartialEq for EnvelopeInliningTestUnion {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::Small(x), Self::Small(y)) => *x == *y,
            (Self::Large(x), Self::Large(y)) => *x == *y,
            (Self::Handle(x), Self::Handle(y)) => *x == *y,
            _ => false,
        }
    }
}

impl EnvelopeInliningTestUnion {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Small(_) => 1,
            Self::Large(_) => 2,
            Self::Handle(_) => 3,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn unknown_variant_for_testing() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0 }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { .. } => true,
            _ => false,
        }
    }
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EnvelopeInliningTestUnion {}

#[derive(Debug)]
pub enum SampleResourceXUnion {
    U(u32),
    Su(SimpleUnion),
    St(SimpleTable),
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u64,
    },
}

/// Pattern that matches an unknown `SampleResourceXUnion` member.
#[macro_export]
macro_rules! SampleResourceXUnionUnknown {
    () => {
        _
    };
}

// Custom PartialEq so that unknown variants are not equal to themselves.
impl PartialEq for SampleResourceXUnion {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::U(x), Self::U(y)) => *x == *y,
            (Self::Su(x), Self::Su(y)) => *x == *y,
            (Self::St(x), Self::St(y)) => *x == *y,
            _ => false,
        }
    }
}

impl SampleResourceXUnion {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::U(_) => 1,
            Self::Su(_) => 2,
            Self::St(_) => 3,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn unknown_variant_for_testing() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0 }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { .. } => true,
            _ => false,
        }
    }
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for SampleResourceXUnion {}

#[derive(Debug, PartialEq)]
pub enum SampleStrictResourceXUnion {
    U(u32),
    Su(SimpleUnion),
    St(SimpleTable),
}

impl SampleStrictResourceXUnion {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::U(_) => 1,
            Self::Su(_) => 2,
            Self::St(_) => 3,
        }
    }
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for SampleStrictResourceXUnion
{
}

#[derive(Debug)]
pub enum UnionOfEndpointsUnion {
    ClientEnd(fidl::endpoints::ClientEnd<ProtocolMarker>),
    ServerEnd(fidl::endpoints::ServerEnd<ProtocolMarker>),
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u64,
    },
}

/// Pattern that matches an unknown `UnionOfEndpointsUnion` member.
#[macro_export]
macro_rules! UnionOfEndpointsUnionUnknown {
    () => {
        _
    };
}

// Custom PartialEq so that unknown variants are not equal to themselves.
impl PartialEq for UnionOfEndpointsUnion {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::ClientEnd(x), Self::ClientEnd(y)) => *x == *y,
            (Self::ServerEnd(x), Self::ServerEnd(y)) => *x == *y,
            _ => false,
        }
    }
}

impl UnionOfEndpointsUnion {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::ClientEnd(_) => 1,
            Self::ServerEnd(_) => 2,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn unknown_variant_for_testing() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0 }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { .. } => true,
            _ => false,
        }
    }
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for UnionOfEndpointsUnion {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum UnionOfHandle {
    H(fidl::NullableHandle),
}

impl UnionOfHandle {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::H(_) => 1,
        }
    }
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for UnionOfHandle {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum UnionWithVector {
    Unused(u8),
    VectorOfUint8(Vec<u8>),
    S(String),
    VectorS3A1(Vec<StructSize3Align1>),
    VectorS3A2(Vec<StructSize3Align2>),
    Handles(Vec<fidl::NullableHandle>),
    ArrayS3A1([StructSize3Align1; 2]),
    ArrayS3A2([StructSize3Align2; 2]),
    VectorUnion(Vec<UnionSize8Align4>),
}

impl UnionWithVector {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Unused(_) => 1,
            Self::VectorOfUint8(_) => 2,
            Self::S(_) => 3,
            Self::VectorS3A1(_) => 4,
            Self::VectorS3A2(_) => 5,
            Self::Handles(_) => 6,
            Self::ArrayS3A1(_) => 7,
            Self::ArrayS3A2(_) => 8,
            Self::VectorUnion(_) => 9,
        }
    }
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for UnionWithVector {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum VectorOfArrayOfEventInUnionWithReducedRights {
    H(Vec<[fidl::Event; 1]>),
}

impl VectorOfArrayOfEventInUnionWithReducedRights {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::H(_) => 1,
        }
    }
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for VectorOfArrayOfEventInUnionWithReducedRights
{
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct ComponentControllerMarker;

impl fidl::endpoints::ProtocolMarker for ComponentControllerMarker {
    type Proxy = ComponentControllerProxy;
    type RequestStream = ComponentControllerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ComponentControllerSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) ComponentController";
}

pub trait ComponentControllerProxyInterface: Send + Sync {}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ComponentControllerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ComponentControllerSynchronousProxy {
    type Proxy = ComponentControllerProxy;
    type Protocol = ComponentControllerMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl ComponentControllerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<ComponentControllerEvent, fidl::Error> {
        ComponentControllerEvent::decode(
            self.client.wait_for_event::<ComponentControllerMarker>(deadline)?,
        )
    }
}

#[cfg(target_os = "fuchsia")]
impl From<ComponentControllerSynchronousProxy> for zx::NullableHandle {
    fn from(value: ComponentControllerSynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for ComponentControllerSynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for ComponentControllerSynchronousProxy {
    type Protocol = ComponentControllerMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<ComponentControllerMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct ComponentControllerProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for ComponentControllerProxy {
    type Protocol = ComponentControllerMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl ComponentControllerProxy {
    /// Create a new Proxy for test.conformance/ComponentController.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <ComponentControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> ComponentControllerEventStream {
        ComponentControllerEventStream { event_receiver: self.client.take_event_receiver() }
    }
}

impl ComponentControllerProxyInterface for ComponentControllerProxy {}

pub struct ComponentControllerEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for ComponentControllerEventStream {}

impl futures::stream::FusedStream for ComponentControllerEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for ComponentControllerEventStream {
    type Item = Result<ComponentControllerEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(ComponentControllerEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum ComponentControllerEvent {}

impl ComponentControllerEvent {
    /// Decodes a message buffer as a [`ComponentControllerEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<ComponentControllerEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <ComponentControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for test.conformance/ComponentController.
pub struct ComponentControllerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for ComponentControllerRequestStream {}

impl futures::stream::FusedStream for ComponentControllerRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for ComponentControllerRequestStream {
    type Protocol = ComponentControllerMarker;
    type ControlHandle = ComponentControllerControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        ComponentControllerControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for ComponentControllerRequestStream {
    type Item = Result<ComponentControllerRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled ComponentControllerRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <ComponentControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

#[derive(Debug)]
pub enum ComponentControllerRequest {}

impl ComponentControllerRequest {
    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {}
    }
}

#[derive(Debug, Clone)]
pub struct ComponentControllerControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl ComponentControllerControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

impl fidl::endpoints::ControlHandle for ComponentControllerControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl ComponentControllerControlHandle {}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct ProtocolMarker;

impl fidl::endpoints::ProtocolMarker for ProtocolMarker {
    type Proxy = ProtocolProxy;
    type RequestStream = ProtocolRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ProtocolSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Protocol";
}

pub trait ProtocolProxyInterface: Send + Sync {}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ProtocolSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ProtocolSynchronousProxy {
    type Proxy = ProtocolProxy;
    type Protocol = ProtocolMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl ProtocolSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        Self { client: fidl::client::sync::Client::new(channel) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<ProtocolEvent, fidl::Error> {
        ProtocolEvent::decode(self.client.wait_for_event::<ProtocolMarker>(deadline)?)
    }
}

#[cfg(target_os = "fuchsia")]
impl From<ProtocolSynchronousProxy> for zx::NullableHandle {
    fn from(value: ProtocolSynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for ProtocolSynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for ProtocolSynchronousProxy {
    type Protocol = ProtocolMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<ProtocolMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct ProtocolProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for ProtocolProxy {
    type Protocol = ProtocolMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl ProtocolProxy {
    /// Create a new Proxy for test.conformance/Protocol.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ProtocolMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> ProtocolEventStream {
        ProtocolEventStream { event_receiver: self.client.take_event_receiver() }
    }
}

impl ProtocolProxyInterface for ProtocolProxy {}

pub struct ProtocolEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for ProtocolEventStream {}

impl futures::stream::FusedStream for ProtocolEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for ProtocolEventStream {
    type Item = Result<ProtocolEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(ProtocolEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum ProtocolEvent {}

impl ProtocolEvent {
    /// Decodes a message buffer as a [`ProtocolEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<ProtocolEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <ProtocolMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for test.conformance/Protocol.
pub struct ProtocolRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for ProtocolRequestStream {}

impl futures::stream::FusedStream for ProtocolRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for ProtocolRequestStream {
    type Protocol = ProtocolMarker;
    type ControlHandle = ProtocolControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        ProtocolControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for ProtocolRequestStream {
    type Item = Result<ProtocolRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled ProtocolRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ProtocolMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum ProtocolRequest {}

impl ProtocolRequest {
    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {}
    }
}

#[derive(Debug, Clone)]
pub struct ProtocolControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl ProtocolControlHandle {
    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
        self.inner.shutdown_with_epitaph(status.into())
    }
}

impl fidl::endpoints::ControlHandle for ProtocolControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }

    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl ProtocolControlHandle {}

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for AlternatingHandlesAndFailures {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for AlternatingHandlesAndFailures {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            56
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            AlternatingHandlesAndFailures,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut AlternatingHandlesAndFailures
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AlternatingHandlesAndFailures>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                AlternatingHandlesAndFailures,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.h1
                    ),
                    <fidl::encoding::BoundedString<1> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.failure_trigger1,
                    ),
                    <fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.h2
                    ),
                    <fidl::encoding::BoundedString<1> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.failure_trigger2,
                    ),
                    <fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.h3
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::NullableHandle,
                    { fidl::ObjectType::NONE.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::BoundedString<1>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::NullableHandle,
                    { fidl::ObjectType::NONE.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T3: fidl::encoding::Encode<
                fidl::encoding::BoundedString<1>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T4: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::NullableHandle,
                    { fidl::ObjectType::NONE.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            AlternatingHandlesAndFailures,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2, T3, T4)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AlternatingHandlesAndFailures>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
                (ptr as *mut u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(48);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            self.3.encode(encoder, offset + 32, depth)?;
            self.4.encode(encoder, offset + 48, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for AlternatingHandlesAndFailures
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                h1: fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                failure_trigger1: fidl::new_empty!(
                    fidl::encoding::BoundedString<1>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                h2: fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                failure_trigger2: fidl::new_empty!(
                    fidl::encoding::BoundedString<1>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                h3: fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(48) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 48 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.h1, decoder, offset + 0, _depth)?;
            fidl::decode!(
                fidl::encoding::BoundedString<1>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.failure_trigger1,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.h2, decoder, offset + 24, _depth)?;
            fidl::decode!(
                fidl::encoding::BoundedString<1>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.failure_trigger2,
                decoder,
                offset + 32,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.h3, decoder, offset + 48, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ArrayOfArrayOfNonnullableHandles {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ArrayOfArrayOfNonnullableHandles {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            48
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ArrayOfArrayOfNonnullableHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ArrayOfArrayOfNonnullableHandles
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ArrayOfArrayOfNonnullableHandles>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ArrayOfArrayOfNonnullableHandles,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Array<
                    fidl::encoding::Array<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                        3,
                    >,
                    4,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.handles
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Array<
                    fidl::encoding::Array<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                        3,
                    >,
                    4,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ArrayOfArrayOfNonnullableHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ArrayOfArrayOfNonnullableHandles>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ArrayOfArrayOfNonnullableHandles
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                handles: fidl::new_empty!(
                    fidl::encoding::Array<
                        fidl::encoding::Array<
                            fidl::encoding::HandleType<
                                fidl::NullableHandle,
                                { fidl::ObjectType::NONE.into_raw() },
                                2147483648,
                            >,
                            3,
                        >,
                        4,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Array<
                    fidl::encoding::Array<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                        3,
                    >,
                    4,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.handles,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ArrayOfHandles {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ArrayOfHandles {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            12
        }
    }

    unsafe impl
        fidl::encoding::Encode<ArrayOfHandles, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut ArrayOfHandles
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ArrayOfHandles>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ArrayOfHandles, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Array<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.a),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Array<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                    3,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    > fidl::encoding::Encode<ArrayOfHandles, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ArrayOfHandles>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ArrayOfHandles
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                a: fidl::new_empty!(
                    fidl::encoding::Array<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                        3,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Array<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                    3,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.a,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ArrayOfNonnullableHandles {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ArrayOfNonnullableHandles {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ArrayOfNonnullableHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ArrayOfNonnullableHandles
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ArrayOfNonnullableHandles>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ArrayOfNonnullableHandles,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Array<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                    4,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.handles
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Array<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                    4,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ArrayOfNonnullableHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ArrayOfNonnullableHandles>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ArrayOfNonnullableHandles
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                handles: fidl::new_empty!(
                    fidl::encoding::Array<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                        4,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Array<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                    4,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.handles,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ArrayOfNullableHandles {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ArrayOfNullableHandles {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            20
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ArrayOfNullableHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ArrayOfNullableHandles
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ArrayOfNullableHandles>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ArrayOfNullableHandles,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Array<
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    >,
                    5,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.handles
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Array<
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    >,
                    5,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ArrayOfNullableHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ArrayOfNullableHandles>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ArrayOfNullableHandles
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                handles: fidl::new_empty!(
                    fidl::encoding::Array<
                        fidl::encoding::Optional<
                            fidl::encoding::HandleType<
                                fidl::NullableHandle,
                                { fidl::ObjectType::NONE.into_raw() },
                                2147483648,
                            >,
                        >,
                        5,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Array<
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    >,
                    5,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.handles,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ArrayOfOptionalHandles {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ArrayOfOptionalHandles {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            12
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ArrayOfOptionalHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ArrayOfOptionalHandles
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ArrayOfOptionalHandles>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ArrayOfOptionalHandles,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Array<
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    >,
                    3,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.a
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Array<
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    >,
                    3,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ArrayOfOptionalHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ArrayOfOptionalHandles>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ArrayOfOptionalHandles
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                a: fidl::new_empty!(
                    fidl::encoding::Array<
                        fidl::encoding::Optional<
                            fidl::encoding::HandleType<
                                fidl::NullableHandle,
                                { fidl::ObjectType::NONE.into_raw() },
                                2147483648,
                            >,
                        >,
                        3,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Array<
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    >,
                    3,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.a,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ArrayOfVectorOfEventInStructWithDefaultRights {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ArrayOfVectorOfEventInStructWithDefaultRights {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ArrayOfVectorOfEventInStructWithDefaultRights,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ArrayOfVectorOfEventInStructWithDefaultRights
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ArrayOfVectorOfEventInStructWithDefaultRights>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ArrayOfVectorOfEventInStructWithDefaultRights,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Array<
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            53251,
                        >,
                        1,
                    >,
                    1,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.h
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Array<
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            53251,
                        >,
                        1,
                    >,
                    1,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ArrayOfVectorOfEventInStructWithDefaultRights,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ArrayOfVectorOfEventInStructWithDefaultRights>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ArrayOfVectorOfEventInStructWithDefaultRights
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                h: fidl::new_empty!(
                    fidl::encoding::Array<
                        fidl::encoding::Vector<
                            fidl::encoding::HandleType<
                                fidl::Event,
                                { fidl::ObjectType::EVENT.into_raw() },
                                53251,
                            >,
                            1,
                        >,
                        1,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Array<
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            53251,
                        >,
                        1,
                    >,
                    1,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.h,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ArrayOfVectorOfEventInStructWithReducedRights {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ArrayOfVectorOfEventInStructWithReducedRights {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ArrayOfVectorOfEventInStructWithReducedRights,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ArrayOfVectorOfEventInStructWithReducedRights
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ArrayOfVectorOfEventInStructWithReducedRights>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ArrayOfVectorOfEventInStructWithReducedRights,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Array<
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            49155,
                        >,
                        1,
                    >,
                    1,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.h
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Array<
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            49155,
                        >,
                        1,
                    >,
                    1,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ArrayOfVectorOfEventInStructWithReducedRights,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ArrayOfVectorOfEventInStructWithReducedRights>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ArrayOfVectorOfEventInStructWithReducedRights
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                h: fidl::new_empty!(
                    fidl::encoding::Array<
                        fidl::encoding::Vector<
                            fidl::encoding::HandleType<
                                fidl::Event,
                                { fidl::ObjectType::EVENT.into_raw() },
                                49155,
                            >,
                            1,
                        >,
                        1,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Array<
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            49155,
                        >,
                        1,
                    >,
                    1,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.h,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ArrayOfVectorOfEventInTableWithDefaultRightsStruct {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ArrayOfVectorOfEventInTableWithDefaultRightsStruct {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ArrayOfVectorOfEventInTableWithDefaultRightsStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ArrayOfVectorOfEventInTableWithDefaultRightsStruct
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<ArrayOfVectorOfEventInTableWithDefaultRightsStruct>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ArrayOfVectorOfEventInTableWithDefaultRightsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <ArrayOfVectorOfEventInTableWithDefaultRights as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.t),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                ArrayOfVectorOfEventInTableWithDefaultRights,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ArrayOfVectorOfEventInTableWithDefaultRightsStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<ArrayOfVectorOfEventInTableWithDefaultRightsStruct>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ArrayOfVectorOfEventInTableWithDefaultRightsStruct
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                t: fidl::new_empty!(
                    ArrayOfVectorOfEventInTableWithDefaultRights,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                ArrayOfVectorOfEventInTableWithDefaultRights,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.t,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ArrayOfVectorOfEventInTableWithReducedRightsStruct {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ArrayOfVectorOfEventInTableWithReducedRightsStruct {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ArrayOfVectorOfEventInTableWithReducedRightsStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ArrayOfVectorOfEventInTableWithReducedRightsStruct
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<ArrayOfVectorOfEventInTableWithReducedRightsStruct>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ArrayOfVectorOfEventInTableWithReducedRightsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <ArrayOfVectorOfEventInTableWithReducedRights as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.t),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                ArrayOfVectorOfEventInTableWithReducedRights,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ArrayOfVectorOfEventInTableWithReducedRightsStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<ArrayOfVectorOfEventInTableWithReducedRightsStruct>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ArrayOfVectorOfEventInTableWithReducedRightsStruct
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                t: fidl::new_empty!(
                    ArrayOfVectorOfEventInTableWithReducedRights,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                ArrayOfVectorOfEventInTableWithReducedRights,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.t,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ArrayOfVectorOfEventInUnionWithDefaultRightsStruct {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ArrayOfVectorOfEventInUnionWithDefaultRightsStruct {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ArrayOfVectorOfEventInUnionWithDefaultRightsStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ArrayOfVectorOfEventInUnionWithDefaultRightsStruct
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<ArrayOfVectorOfEventInUnionWithDefaultRightsStruct>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ArrayOfVectorOfEventInUnionWithDefaultRightsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <ArrayOfVectorOfEventInUnionWithDefaultRights as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.u),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                ArrayOfVectorOfEventInUnionWithDefaultRights,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ArrayOfVectorOfEventInUnionWithDefaultRightsStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<ArrayOfVectorOfEventInUnionWithDefaultRightsStruct>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ArrayOfVectorOfEventInUnionWithDefaultRightsStruct
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                u: fidl::new_empty!(
                    ArrayOfVectorOfEventInUnionWithDefaultRights,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                ArrayOfVectorOfEventInUnionWithDefaultRights,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.u,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ArrayOfVectorOfEventInUnionWithReducedRightsStruct {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ArrayOfVectorOfEventInUnionWithReducedRightsStruct {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ArrayOfVectorOfEventInUnionWithReducedRightsStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ArrayOfVectorOfEventInUnionWithReducedRightsStruct
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<ArrayOfVectorOfEventInUnionWithReducedRightsStruct>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ArrayOfVectorOfEventInUnionWithReducedRightsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <ArrayOfVectorOfEventInUnionWithReducedRights as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.u),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                ArrayOfVectorOfEventInUnionWithReducedRights,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ArrayOfVectorOfEventInUnionWithReducedRightsStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<ArrayOfVectorOfEventInUnionWithReducedRightsStruct>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ArrayOfVectorOfEventInUnionWithReducedRightsStruct
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                u: fidl::new_empty!(
                    ArrayOfVectorOfEventInUnionWithReducedRights,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                ArrayOfVectorOfEventInUnionWithReducedRights,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.u,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for Bounded32NonnullableVectorOfHandles {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Bounded32NonnullableVectorOfHandles {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            Bounded32NonnullableVectorOfHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut Bounded32NonnullableVectorOfHandles
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Bounded32NonnullableVectorOfHandles>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                Bounded32NonnullableVectorOfHandles,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Vector<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                    32,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.vh0
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Vector<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                    32,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            Bounded32NonnullableVectorOfHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Bounded32NonnullableVectorOfHandles>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for Bounded32NonnullableVectorOfHandles
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vh0: fidl::new_empty!(
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                        32,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Vector<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                    32,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.vh0,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for Bounded32NullableVectorOfHandles {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Bounded32NullableVectorOfHandles {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            Bounded32NullableVectorOfHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut Bounded32NullableVectorOfHandles
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Bounded32NullableVectorOfHandles>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                Bounded32NullableVectorOfHandles,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Optional<
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                        32,
                    >,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.vh0
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                        32,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            Bounded32NullableVectorOfHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Bounded32NullableVectorOfHandles>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for Bounded32NullableVectorOfHandles
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vh0: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Vector<
                            fidl::encoding::HandleType<
                                fidl::NullableHandle,
                                { fidl::ObjectType::NONE.into_raw() },
                                2147483648,
                            >,
                            32,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                        32,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.vh0,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for BoxOfSingleHandle {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for BoxOfSingleHandle {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
    }

    unsafe impl
        fidl::encoding::Encode<BoxOfSingleHandle, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut BoxOfSingleHandle
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BoxOfSingleHandle>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<BoxOfSingleHandle, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Boxed<SingleHandle> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.b),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Boxed<SingleHandle>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    > fidl::encoding::Encode<BoxOfSingleHandle, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BoxOfSingleHandle>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for BoxOfSingleHandle
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                b: fidl::new_empty!(
                    fidl::encoding::Boxed<SingleHandle>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Boxed<SingleHandle>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.b,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for BoxOfSingleOptionalHandle {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for BoxOfSingleOptionalHandle {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            BoxOfSingleOptionalHandle,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut BoxOfSingleOptionalHandle
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BoxOfSingleOptionalHandle>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<BoxOfSingleOptionalHandle, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Boxed<SingleOptionalHandle> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.b),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Boxed<SingleOptionalHandle>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            BoxOfSingleOptionalHandle,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BoxOfSingleOptionalHandle>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for BoxOfSingleOptionalHandle
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                b: fidl::new_empty!(
                    fidl::encoding::Boxed<SingleOptionalHandle>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Boxed<SingleOptionalHandle>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.b,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for CreateComponentRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for CreateComponentRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            80
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            CreateComponentRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut CreateComponentRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CreateComponentRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                CreateComponentRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <LaunchInfo as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.launch_info,
                    ),
                    <fidl::encoding::Optional<
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ServerEnd<ComponentControllerMarker>,
                        >,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.controller
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<LaunchInfo, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ComponentControllerMarker>>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            CreateComponentRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CreateComponentRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(72);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 72, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CreateComponentRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                launch_info: fidl::new_empty!(
                    LaunchInfo,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                controller: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ServerEnd<ComponentControllerMarker>,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(72) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 72 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                LaunchInfo,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.launch_info,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ComponentControllerMarker>>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.controller,
                decoder,
                offset + 72,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for EmptyResourceTableStruct {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for EmptyResourceTableStruct {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            EmptyResourceTableStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut EmptyResourceTableStruct
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EmptyResourceTableStruct>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                EmptyResourceTableStruct,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<EmptyResourceTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.table,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<EmptyResourceTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
    >
        fidl::encoding::Encode<
            EmptyResourceTableStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EmptyResourceTableStruct>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for EmptyResourceTableStruct
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                table: fidl::new_empty!(
                    EmptyResourceTable,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                EmptyResourceTable,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.table,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for EnvelopeInliningTestUnionStruct {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for EnvelopeInliningTestUnionStruct {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            EnvelopeInliningTestUnionStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut EnvelopeInliningTestUnionStruct
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EnvelopeInliningTestUnionStruct>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<EnvelopeInliningTestUnionStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <EnvelopeInliningTestUnion as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.u),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                EnvelopeInliningTestUnion,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            EnvelopeInliningTestUnionStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EnvelopeInliningTestUnionStruct>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for EnvelopeInliningTestUnionStruct
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                u: fidl::new_empty!(
                    EnvelopeInliningTestUnion,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                EnvelopeInliningTestUnion,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.u,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for EventWithDefaultRights {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for EventWithDefaultRights {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            EventWithDefaultRights,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut EventWithDefaultRights
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EventWithDefaultRights>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                EventWithDefaultRights,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fidl::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    53251,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.h
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    53251,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            EventWithDefaultRights,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EventWithDefaultRights>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for EventWithDefaultRights
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                h: fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 53251>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 53251>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.h, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for EventWithReducedRights {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for EventWithReducedRights {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            EventWithReducedRights,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut EventWithReducedRights
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EventWithReducedRights>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                EventWithReducedRights,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fidl::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    49155,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.h
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    49155,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            EventWithReducedRights,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EventWithReducedRights>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for EventWithReducedRights
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                h: fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 49155>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 49155>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.h, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for FidlvizDemo {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FidlvizDemo {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            248
        }
    }

    unsafe impl fidl::encoding::Encode<FidlvizDemo, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut FidlvizDemo
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FidlvizDemo>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FidlvizDemo, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.f1),
                    <i8 as fidl::encoding::ValueTypeMarker>::borrow(&self.f2),
                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.f3),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.f4),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.f5),
                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.f6),
                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(&self.f7),
                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.f8),
                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(&self.f9),
                    <f64 as fidl::encoding::ValueTypeMarker>::borrow(&self.f10),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.f11),
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.f12),
                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(&self.f13),
                    <fidl::encoding::Optional<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow(&self.f14),
                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(&self.f15),
                    <fidl::encoding::Optional<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.f16),
                    <fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.f17),
                    <fidl::encoding::Array<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f18),
                    <fidl::encoding::UnboundedVector<f64> as fidl::encoding::ValueTypeMarker>::borrow(&self.f19),
                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<u8>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f20),
                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.f21),
                    <FidlvizBits as fidl::encoding::ValueTypeMarker>::borrow(&self.f22),
                    <FidlvizEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.f23),
                    <FidlvizStruct1 as fidl::encoding::ValueTypeMarker>::borrow(&self.f24),
                    <FidlvizStruct2 as fidl::encoding::ValueTypeMarker>::borrow(&self.f25),
                    <fidl::encoding::Boxed<FidlvizStruct1> as fidl::encoding::ValueTypeMarker>::borrow(&self.f26),
                    <fidl::encoding::Boxed<FidlvizStruct2> as fidl::encoding::ValueTypeMarker>::borrow(&self.f27),
                    <FidlvizTable as fidl::encoding::ValueTypeMarker>::borrow(&self.f28),
                    <FidlvizTable as fidl::encoding::ValueTypeMarker>::borrow(&self.f29),
                    <fidl::encoding::OptionalUnion<FidlvizUnion> as fidl::encoding::ValueTypeMarker>::borrow(&self.f30),
                    <FidlvizUnion as fidl::encoding::ValueTypeMarker>::borrow(&self.f31),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u8, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<i8, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<u16, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T3: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T4: fidl::encoding::Encode<u64, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T5: fidl::encoding::Encode<u8, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T6: fidl::encoding::Encode<u8, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T7: fidl::encoding::Encode<u16, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T8: fidl::encoding::Encode<f32, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T9: fidl::encoding::Encode<f64, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T10: fidl::encoding::Encode<bool, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T11: fidl::encoding::Encode<bool, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T12: fidl::encoding::Encode<
                fidl::encoding::UnboundedString,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T13: fidl::encoding::Encode<
                fidl::encoding::Optional<fidl::encoding::UnboundedString>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T14: fidl::encoding::Encode<
                fidl::encoding::UnboundedString,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T15: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T16: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::NullableHandle,
                    { fidl::ObjectType::NONE.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T17: fidl::encoding::Encode<
                fidl::encoding::Array<u8, 3>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T18: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<f64>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T19: fidl::encoding::Encode<
                fidl::encoding::Optional<fidl::encoding::UnboundedVector<u8>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T20: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<u8>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T21: fidl::encoding::Encode<FidlvizBits, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T22: fidl::encoding::Encode<FidlvizEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T23: fidl::encoding::Encode<FidlvizStruct1, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T24: fidl::encoding::Encode<FidlvizStruct2, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T25: fidl::encoding::Encode<
                fidl::encoding::Boxed<FidlvizStruct1>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T26: fidl::encoding::Encode<
                fidl::encoding::Boxed<FidlvizStruct2>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T27: fidl::encoding::Encode<FidlvizTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T28: fidl::encoding::Encode<FidlvizTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T29: fidl::encoding::Encode<
                fidl::encoding::OptionalUnion<FidlvizUnion>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T30: fidl::encoding::Encode<FidlvizUnion, fidl::encoding::DefaultFuchsiaResourceDialect>,
    > fidl::encoding::Encode<FidlvizDemo, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (
            T0,
            T1,
            T2,
            T3,
            T4,
            T5,
            T6,
            T7,
            T8,
            T9,
            T10,
            T11,
            T12,
            T13,
            T14,
            T15,
            T16,
            T17,
            T18,
            T19,
            T20,
            T21,
            T22,
            T23,
            T24,
            T25,
            T26,
            T27,
            T28,
            T29,
            T30,
        )
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FidlvizDemo>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(96);
                (ptr as *mut u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(152);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 1, depth)?;
            self.2.encode(encoder, offset + 2, depth)?;
            self.3.encode(encoder, offset + 4, depth)?;
            self.4.encode(encoder, offset + 8, depth)?;
            self.5.encode(encoder, offset + 16, depth)?;
            self.6.encode(encoder, offset + 17, depth)?;
            self.7.encode(encoder, offset + 18, depth)?;
            self.8.encode(encoder, offset + 20, depth)?;
            self.9.encode(encoder, offset + 24, depth)?;
            self.10.encode(encoder, offset + 32, depth)?;
            self.11.encode(encoder, offset + 33, depth)?;
            self.12.encode(encoder, offset + 40, depth)?;
            self.13.encode(encoder, offset + 56, depth)?;
            self.14.encode(encoder, offset + 72, depth)?;
            self.15.encode(encoder, offset + 88, depth)?;
            self.16.encode(encoder, offset + 92, depth)?;
            self.17.encode(encoder, offset + 96, depth)?;
            self.18.encode(encoder, offset + 104, depth)?;
            self.19.encode(encoder, offset + 120, depth)?;
            self.20.encode(encoder, offset + 136, depth)?;
            self.21.encode(encoder, offset + 152, depth)?;
            self.22.encode(encoder, offset + 153, depth)?;
            self.23.encode(encoder, offset + 154, depth)?;
            self.24.encode(encoder, offset + 160, depth)?;
            self.25.encode(encoder, offset + 168, depth)?;
            self.26.encode(encoder, offset + 176, depth)?;
            self.27.encode(encoder, offset + 184, depth)?;
            self.28.encode(encoder, offset + 200, depth)?;
            self.29.encode(encoder, offset + 216, depth)?;
            self.30.encode(encoder, offset + 232, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for FidlvizDemo {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                f1: fidl::new_empty!(u8, fidl::encoding::DefaultFuchsiaResourceDialect),
                f2: fidl::new_empty!(i8, fidl::encoding::DefaultFuchsiaResourceDialect),
                f3: fidl::new_empty!(u16, fidl::encoding::DefaultFuchsiaResourceDialect),
                f4: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
                f5: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
                f6: fidl::new_empty!(u8, fidl::encoding::DefaultFuchsiaResourceDialect),
                f7: fidl::new_empty!(u8, fidl::encoding::DefaultFuchsiaResourceDialect),
                f8: fidl::new_empty!(u16, fidl::encoding::DefaultFuchsiaResourceDialect),
                f9: fidl::new_empty!(f32, fidl::encoding::DefaultFuchsiaResourceDialect),
                f10: fidl::new_empty!(f64, fidl::encoding::DefaultFuchsiaResourceDialect),
                f11: fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect),
                f12: fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect),
                f13: fidl::new_empty!(
                    fidl::encoding::UnboundedString,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                f14: fidl::new_empty!(
                    fidl::encoding::Optional<fidl::encoding::UnboundedString>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                f15: fidl::new_empty!(
                    fidl::encoding::UnboundedString,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                f16: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                f17: fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                f18: fidl::new_empty!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
                f19: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<f64>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                f20: fidl::new_empty!(
                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u8>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                f21: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<u8>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                f22: fidl::new_empty!(FidlvizBits, fidl::encoding::DefaultFuchsiaResourceDialect),
                f23: fidl::new_empty!(FidlvizEnum, fidl::encoding::DefaultFuchsiaResourceDialect),
                f24: fidl::new_empty!(
                    FidlvizStruct1,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                f25: fidl::new_empty!(
                    FidlvizStruct2,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                f26: fidl::new_empty!(
                    fidl::encoding::Boxed<FidlvizStruct1>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                f27: fidl::new_empty!(
                    fidl::encoding::Boxed<FidlvizStruct2>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                f28: fidl::new_empty!(FidlvizTable, fidl::encoding::DefaultFuchsiaResourceDialect),
                f29: fidl::new_empty!(FidlvizTable, fidl::encoding::DefaultFuchsiaResourceDialect),
                f30: fidl::new_empty!(
                    fidl::encoding::OptionalUnion<FidlvizUnion>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                f31: fidl::new_empty!(FidlvizUnion, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffffffff0000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(96) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffffff000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 96 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(152) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffffff000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 152 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                u8,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f1,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                i8,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f2,
                decoder,
                offset + 1,
                _depth
            )?;
            fidl::decode!(
                u16,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f3,
                decoder,
                offset + 2,
                _depth
            )?;
            fidl::decode!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f4,
                decoder,
                offset + 4,
                _depth
            )?;
            fidl::decode!(
                u64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f5,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                u8,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f6,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                u8,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f7,
                decoder,
                offset + 17,
                _depth
            )?;
            fidl::decode!(
                u16,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f8,
                decoder,
                offset + 18,
                _depth
            )?;
            fidl::decode!(
                f32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f9,
                decoder,
                offset + 20,
                _depth
            )?;
            fidl::decode!(
                f64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f10,
                decoder,
                offset + 24,
                _depth
            )?;
            fidl::decode!(
                bool,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f11,
                decoder,
                offset + 32,
                _depth
            )?;
            fidl::decode!(
                bool,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f12,
                decoder,
                offset + 33,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::UnboundedString,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f13,
                decoder,
                offset + 40,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<fidl::encoding::UnboundedString>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f14,
                decoder,
                offset + 56,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::UnboundedString,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f15,
                decoder,
                offset + 72,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f16,
                decoder,
                offset + 88,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f17, decoder, offset + 92, _depth)?;
            fidl::decode!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f18, decoder, offset + 96, _depth)?;
            fidl::decode!(
                fidl::encoding::UnboundedVector<f64>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f19,
                decoder,
                offset + 104,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<fidl::encoding::UnboundedVector<u8>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f20,
                decoder,
                offset + 120,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::UnboundedVector<u8>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f21,
                decoder,
                offset + 136,
                _depth
            )?;
            fidl::decode!(
                FidlvizBits,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f22,
                decoder,
                offset + 152,
                _depth
            )?;
            fidl::decode!(
                FidlvizEnum,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f23,
                decoder,
                offset + 153,
                _depth
            )?;
            fidl::decode!(
                FidlvizStruct1,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f24,
                decoder,
                offset + 154,
                _depth
            )?;
            fidl::decode!(
                FidlvizStruct2,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f25,
                decoder,
                offset + 160,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Boxed<FidlvizStruct1>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f26,
                decoder,
                offset + 168,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Boxed<FidlvizStruct2>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f27,
                decoder,
                offset + 176,
                _depth
            )?;
            fidl::decode!(
                FidlvizTable,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f28,
                decoder,
                offset + 184,
                _depth
            )?;
            fidl::decode!(
                FidlvizTable,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f29,
                decoder,
                offset + 200,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::OptionalUnion<FidlvizUnion>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f30,
                decoder,
                offset + 216,
                _depth
            )?;
            fidl::decode!(
                FidlvizUnion,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.f31,
                decoder,
                offset + 232,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for GoldenHandleBasicRightsStruct {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for GoldenHandleBasicRightsStruct {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            GoldenHandleBasicRightsStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut GoldenHandleBasicRightsStruct
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<GoldenHandleBasicRightsStruct>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                GoldenHandleBasicRightsStruct,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::HandleType<
                    fidl::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    49155,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.v
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    49155,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            GoldenHandleBasicRightsStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<GoldenHandleBasicRightsStruct>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for GoldenHandleBasicRightsStruct
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                v: fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 49155>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 49155>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.v, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for GoldenNullableHandleStruct {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for GoldenNullableHandleStruct {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            GoldenNullableHandleStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut GoldenNullableHandleStruct
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<GoldenNullableHandleStruct>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                GoldenNullableHandleStruct,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.v
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            GoldenNullableHandleStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<GoldenNullableHandleStruct>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for GoldenNullableHandleStruct
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                v: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.v,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for LaunchInfo {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for LaunchInfo {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            72
        }
    }

    unsafe impl fidl::encoding::Encode<LaunchInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut LaunchInfo
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LaunchInfo>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<LaunchInfo, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<200> as fidl::encoding::ValueTypeMarker>::borrow(&self.url),
                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>> as fidl::encoding::ValueTypeMarker>::borrow(&self.arguments),
                    <fidl::encoding::Boxed<TransformerEmptyStruct> as fidl::encoding::ValueTypeMarker>::borrow(&self.out),
                    <fidl::encoding::Boxed<TransformerEmptyStruct> as fidl::encoding::ValueTypeMarker>::borrow(&self.err),
                    <fidl::encoding::Optional<fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.directory_request),
                    <fidl::encoding::Boxed<TransformerEmptyStruct> as fidl::encoding::ValueTypeMarker>::borrow(&self.flat_namespace),
                    <fidl::encoding::Boxed<TransformerEmptyStruct> as fidl::encoding::ValueTypeMarker>::borrow(&self.additional_services),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<200>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::Boxed<TransformerEmptyStruct>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T3: fidl::encoding::Encode<
                fidl::encoding::Boxed<TransformerEmptyStruct>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T4: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Channel,
                        { fidl::ObjectType::CHANNEL.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T5: fidl::encoding::Encode<
                fidl::encoding::Boxed<TransformerEmptyStruct>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T6: fidl::encoding::Encode<
                fidl::encoding::Boxed<TransformerEmptyStruct>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    > fidl::encoding::Encode<LaunchInfo, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1, T2, T3, T4, T5, T6)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LaunchInfo>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(48);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            self.3.encode(encoder, offset + 40, depth)?;
            self.4.encode(encoder, offset + 48, depth)?;
            self.5.encode(encoder, offset + 56, depth)?;
            self.6.encode(encoder, offset + 64, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for LaunchInfo {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                url: fidl::new_empty!(
                    fidl::encoding::BoundedString<200>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                arguments: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                out: fidl::new_empty!(
                    fidl::encoding::Boxed<TransformerEmptyStruct>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                err: fidl::new_empty!(
                    fidl::encoding::Boxed<TransformerEmptyStruct>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                directory_request: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::Channel,
                            { fidl::ObjectType::CHANNEL.into_raw() },
                            2147483648,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                flat_namespace: fidl::new_empty!(
                    fidl::encoding::Boxed<TransformerEmptyStruct>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                additional_services: fidl::new_empty!(
                    fidl::encoding::Boxed<TransformerEmptyStruct>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(48) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 48 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::BoundedString<200>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.url,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.arguments,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Boxed<TransformerEmptyStruct>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.out,
                decoder,
                offset + 32,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Boxed<TransformerEmptyStruct>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.err,
                decoder,
                offset + 40,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Channel,
                        { fidl::ObjectType::CHANNEL.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.directory_request,
                decoder,
                offset + 48,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Boxed<TransformerEmptyStruct>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.flat_namespace,
                decoder,
                offset + 56,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Boxed<TransformerEmptyStruct>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.additional_services,
                decoder,
                offset + 64,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for MultipleBoundedNonnullableVectorsOfHandles {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for MultipleBoundedNonnullableVectorsOfHandles {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            32
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            MultipleBoundedNonnullableVectorsOfHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut MultipleBoundedNonnullableVectorsOfHandles
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MultipleBoundedNonnullableVectorsOfHandles>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                MultipleBoundedNonnullableVectorsOfHandles,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                        2,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.vh0
                    ),
                    <fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                        32,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.vh1
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Vector<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                    2,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Vector<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                    32,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            MultipleBoundedNonnullableVectorsOfHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MultipleBoundedNonnullableVectorsOfHandles>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for MultipleBoundedNonnullableVectorsOfHandles
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vh0: fidl::new_empty!(
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                        2,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                vh1: fidl::new_empty!(
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                        32,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Vector<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                    2,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.vh0,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Vector<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                    32,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.vh1,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for MultipleBoundedNullableVectorsOfHandles {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for MultipleBoundedNullableVectorsOfHandles {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            32
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            MultipleBoundedNullableVectorsOfHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut MultipleBoundedNullableVectorsOfHandles
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MultipleBoundedNullableVectorsOfHandles>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                MultipleBoundedNullableVectorsOfHandles,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::Optional<
                        fidl::encoding::Vector<
                            fidl::encoding::HandleType<
                                fidl::NullableHandle,
                                { fidl::ObjectType::NONE.into_raw() },
                                2147483648,
                            >,
                            2,
                        >,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.vh0
                    ),
                    <fidl::encoding::Optional<
                        fidl::encoding::Vector<
                            fidl::encoding::HandleType<
                                fidl::NullableHandle,
                                { fidl::ObjectType::NONE.into_raw() },
                                2147483648,
                            >,
                            32,
                        >,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.vh1
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                        2,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                        32,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            MultipleBoundedNullableVectorsOfHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MultipleBoundedNullableVectorsOfHandles>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for MultipleBoundedNullableVectorsOfHandles
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vh0: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Vector<
                            fidl::encoding::HandleType<
                                fidl::NullableHandle,
                                { fidl::ObjectType::NONE.into_raw() },
                                2147483648,
                            >,
                            2,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                vh1: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Vector<
                            fidl::encoding::HandleType<
                                fidl::NullableHandle,
                                { fidl::ObjectType::NONE.into_raw() },
                                2147483648,
                            >,
                            32,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                        2,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.vh0,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                        32,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.vh1,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for MultipleHandleSubtypes {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for MultipleHandleSubtypes {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            12
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            MultipleHandleSubtypes,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut MultipleHandleSubtypes
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MultipleHandleSubtypes>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                MultipleHandleSubtypes,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.untyped
                    ),
                    <fidl::encoding::HandleType<
                        fidl::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.event
                    ),
                    <fidl::encoding::HandleType<
                        fidl::Channel,
                        { fidl::ObjectType::CHANNEL.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.channel
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::NullableHandle,
                    { fidl::ObjectType::NONE.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            MultipleHandleSubtypes,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MultipleHandleSubtypes>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for MultipleHandleSubtypes
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                untyped: fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                event: fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                channel: fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.untyped, decoder, offset + 0, _depth)?;
            fidl::decode!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.event, decoder, offset + 4, _depth)?;
            fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.channel, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for MultipleNonnullableHandles {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for MultipleNonnullableHandles {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            32
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            MultipleNonnullableHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut MultipleNonnullableHandles
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MultipleNonnullableHandles>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                MultipleNonnullableHandles,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.data0),
                    <fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.handle0
                    ),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.data1),
                    <fidl::encoding::HandleType<
                        fidl::Channel,
                        { fidl::ObjectType::CHANNEL.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.handle1
                    ),
                    <fidl::encoding::HandleType<
                        fidl::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.handle2
                    ),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.data2),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::NullableHandle,
                    { fidl::ObjectType::NONE.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<u64, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T3: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T4: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T5: fidl::encoding::Encode<u64, fidl::encoding::DefaultFuchsiaResourceDialect>,
    >
        fidl::encoding::Encode<
            MultipleNonnullableHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2, T3, T4, T5)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MultipleNonnullableHandles>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            self.3.encode(encoder, offset + 16, depth)?;
            self.4.encode(encoder, offset + 20, depth)?;
            self.5.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for MultipleNonnullableHandles
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                data0: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
                handle0: fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                data1: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
                handle1: fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                handle2: fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                data2: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.data0,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.handle0, decoder, offset + 4, _depth)?;
            fidl::decode!(
                u64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.data1,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.handle1, decoder, offset + 16, _depth)?;
            fidl::decode!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.handle2, decoder, offset + 20, _depth)?;
            fidl::decode!(
                u64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.data2,
                decoder,
                offset + 24,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for MultipleNullableHandles {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for MultipleNullableHandles {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            32
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            MultipleNullableHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut MultipleNullableHandles
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MultipleNullableHandles>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                MultipleNullableHandles,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.data0),
                    <fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.handle0
                    ),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.data1),
                    <fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::Channel,
                            { fidl::ObjectType::CHANNEL.into_raw() },
                            2147483648,
                        >,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.handle1
                    ),
                    <fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            2147483648,
                        >,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.handle2
                    ),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.data2),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<u64, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T3: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Channel,
                        { fidl::ObjectType::CHANNEL.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T4: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T5: fidl::encoding::Encode<u64, fidl::encoding::DefaultFuchsiaResourceDialect>,
    >
        fidl::encoding::Encode<
            MultipleNullableHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2, T3, T4, T5)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MultipleNullableHandles>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            self.3.encode(encoder, offset + 16, depth)?;
            self.4.encode(encoder, offset + 20, depth)?;
            self.5.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for MultipleNullableHandles
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                data0: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
                handle0: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                data1: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
                handle1: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::Channel,
                            { fidl::ObjectType::CHANNEL.into_raw() },
                            2147483648,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                handle2: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            2147483648,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                data2: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.data0,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.handle0,
                decoder,
                offset + 4,
                _depth
            )?;
            fidl::decode!(
                u64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.data1,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Channel,
                        { fidl::ObjectType::CHANNEL.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.handle1,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.handle2,
                decoder,
                offset + 20,
                _depth
            )?;
            fidl::decode!(
                u64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.data2,
                decoder,
                offset + 24,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for NonnullableHandle {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NonnullableHandle {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl
        fidl::encoding::Encode<NonnullableHandle, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut NonnullableHandle
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NonnullableHandle>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NonnullableHandle, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.h),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::NullableHandle,
                    { fidl::ObjectType::NONE.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    > fidl::encoding::Encode<NonnullableHandle, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NonnullableHandle>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for NonnullableHandle
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                h: fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.h, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for NonnullableHandleArray {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NonnullableHandleArray {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            NonnullableHandleArray,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut NonnullableHandleArray
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NonnullableHandleArray>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                NonnullableHandleArray,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Array<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                    4,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.handles
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Array<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                    4,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            NonnullableHandleArray,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NonnullableHandleArray>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for NonnullableHandleArray
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                handles: fidl::new_empty!(
                    fidl::encoding::Array<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                        4,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Array<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                    4,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.handles,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for NullableHandle {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NullableHandle {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl
        fidl::encoding::Encode<NullableHandle, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut NullableHandle
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NullableHandle>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NullableHandle, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Optional<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.h),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    > fidl::encoding::Encode<NullableHandle, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NullableHandle>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for NullableHandle
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                h: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.h,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for OutOfLineArrayOfNonnullableHandles {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for OutOfLineArrayOfNonnullableHandles {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            OutOfLineArrayOfNonnullableHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut OutOfLineArrayOfNonnullableHandles
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<OutOfLineArrayOfNonnullableHandles>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<OutOfLineArrayOfNonnullableHandles, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Boxed<NonnullableHandleArray> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handles),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Boxed<NonnullableHandleArray>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            OutOfLineArrayOfNonnullableHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<OutOfLineArrayOfNonnullableHandles>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for OutOfLineArrayOfNonnullableHandles
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                handles: fidl::new_empty!(
                    fidl::encoding::Boxed<NonnullableHandleArray>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Boxed<NonnullableHandleArray>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.handles,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for Sandwich6 {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Sandwich6 {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            32
        }
    }

    unsafe impl fidl::encoding::Encode<Sandwich6, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut Sandwich6
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Sandwich6>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<Sandwich6, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.before),
                    <UnionWithVector as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.the_union),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.after),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<UnionWithVector, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
    > fidl::encoding::Encode<Sandwich6, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Sandwich6>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(24);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Sandwich6 {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                before: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
                the_union: fidl::new_empty!(
                    UnionWithVector,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                after: fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(24) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 24 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.before,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                UnionWithVector,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.the_union,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.after,
                decoder,
                offset + 24,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ShortStringThenHandle {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ShortStringThenHandle {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            24
        }
    }

    unsafe impl
        fidl::encoding::Encode<ShortStringThenHandle, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut ShortStringThenHandle
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ShortStringThenHandle>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ShortStringThenHandle,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::BoundedString<1> as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.s,
                    ),
                    <fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.h
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<1>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::NullableHandle,
                    { fidl::ObjectType::NONE.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<ShortStringThenHandle, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ShortStringThenHandle>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ShortStringThenHandle
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                s: fidl::new_empty!(
                    fidl::encoding::BoundedString<1>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                h: fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::BoundedString<1>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.s,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.h, decoder, offset + 16, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for SingleHandle {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for SingleHandle {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl fidl::encoding::Encode<SingleHandle, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut SingleHandle
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SingleHandle>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<SingleHandle, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.h),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::HandleType<
                    fidl::NullableHandle,
                    { fidl::ObjectType::NONE.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    > fidl::encoding::Encode<SingleHandle, fidl::encoding::DefaultFuchsiaResourceDialect> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SingleHandle>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for SingleHandle {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                h: fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.h, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for SingleOptionalHandle {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for SingleOptionalHandle {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl
        fidl::encoding::Encode<SingleOptionalHandle, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut SingleOptionalHandle
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SingleOptionalHandle>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                SingleOptionalHandle,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.h
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<SingleOptionalHandle, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SingleOptionalHandle>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for SingleOptionalHandle
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                h: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.h,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for StructOfEndpoints {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for StructOfEndpoints {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<StructOfEndpoints, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut StructOfEndpoints
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StructOfEndpoints>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<StructOfEndpoints, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ProtocolMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.client_end),
                    <fidl::encoding::Optional<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ProtocolMarker>>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.optional_client_end),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProtocolMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.server_end),
                    <fidl::encoding::Optional<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProtocolMarker>>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.optional_server_end),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ProtocolMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ProtocolMarker>>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProtocolMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T3: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProtocolMarker>>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    > fidl::encoding::Encode<StructOfEndpoints, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StructOfEndpoints>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            self.3.encode(encoder, offset + 12, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for StructOfEndpoints
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                client_end: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ProtocolMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                optional_client_end: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ProtocolMarker>>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                server_end: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProtocolMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                optional_server_end: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProtocolMarker>>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ProtocolMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.client_end,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ProtocolMarker>>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.optional_client_end,
                decoder,
                offset + 4,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProtocolMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.server_end,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProtocolMarker>>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.optional_server_end,
                decoder,
                offset + 12,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for StructOfOptionalUnionOfHandle {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for StructOfOptionalUnionOfHandle {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            StructOfOptionalUnionOfHandle,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut StructOfOptionalUnionOfHandle
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StructOfOptionalUnionOfHandle>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<StructOfOptionalUnionOfHandle, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::OptionalUnion<UnionOfHandle> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.u),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::OptionalUnion<UnionOfHandle>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            StructOfOptionalUnionOfHandle,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StructOfOptionalUnionOfHandle>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for StructOfOptionalUnionOfHandle
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                u: fidl::new_empty!(
                    fidl::encoding::OptionalUnion<UnionOfHandle>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::OptionalUnion<UnionOfHandle>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.u,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for StructOfSimpleResourceTable {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for StructOfSimpleResourceTable {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            StructOfSimpleResourceTable,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut StructOfSimpleResourceTable
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StructOfSimpleResourceTable>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                StructOfSimpleResourceTable,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<SimpleResourceTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.table,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<SimpleResourceTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
    >
        fidl::encoding::Encode<
            StructOfSimpleResourceTable,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StructOfSimpleResourceTable>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for StructOfSimpleResourceTable
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                table: fidl::new_empty!(
                    SimpleResourceTable,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                SimpleResourceTable,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.table,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for TableFieldInlinedHandleStruct {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TableFieldInlinedHandleStruct {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            TableFieldInlinedHandleStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut TableFieldInlinedHandleStruct
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TableFieldInlinedHandleStruct>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                TableFieldInlinedHandleStruct,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<TableFieldInlinedHandle as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.t,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                TableFieldInlinedHandle,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            TableFieldInlinedHandleStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TableFieldInlinedHandleStruct>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TableFieldInlinedHandleStruct
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                t: fidl::new_empty!(
                    TableFieldInlinedHandle,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                TableFieldInlinedHandle,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.t,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for TableFieldUnknownResourceStruct {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TableFieldUnknownResourceStruct {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            TableFieldUnknownResourceStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut TableFieldUnknownResourceStruct
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TableFieldUnknownResourceStruct>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<TableFieldUnknownResourceStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <TableFieldUnknownResource as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.t),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                TableFieldUnknownResource,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            TableFieldUnknownResourceStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TableFieldUnknownResourceStruct>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TableFieldUnknownResourceStruct
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                t: fidl::new_empty!(
                    TableFieldUnknownResource,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                TableFieldUnknownResource,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.t,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for TableOfEndpoints {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TableOfEndpoints {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<TableOfEndpoints, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut TableOfEndpoints
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TableOfEndpoints>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<TableOfEndpoints, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <TableOfEndpointsTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.t),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                TableOfEndpointsTable,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    > fidl::encoding::Encode<TableOfEndpoints, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TableOfEndpoints>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TableOfEndpoints
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                t: fidl::new_empty!(
                    TableOfEndpointsTable,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                TableOfEndpointsTable,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.t,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for TableUnionWithVectorReservedSandwichStruct {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TableUnionWithVectorReservedSandwichStruct {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            TableUnionWithVectorReservedSandwichStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut TableUnionWithVectorReservedSandwichStruct
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TableUnionWithVectorReservedSandwichStruct>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<TableUnionWithVectorReservedSandwichStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <TableUnionWithVectorReservedSandwich as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.table),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                TableUnionWithVectorReservedSandwich,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            TableUnionWithVectorReservedSandwichStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TableUnionWithVectorReservedSandwichStruct>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TableUnionWithVectorReservedSandwichStruct
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                table: fidl::new_empty!(
                    TableUnionWithVectorReservedSandwich,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                TableUnionWithVectorReservedSandwich,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.table,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for TableUnionWithVectorStructSandwichStruct {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TableUnionWithVectorStructSandwichStruct {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            TableUnionWithVectorStructSandwichStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut TableUnionWithVectorStructSandwichStruct
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TableUnionWithVectorStructSandwichStruct>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<TableUnionWithVectorStructSandwichStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <TableUnionWithVectorStructSandwich as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.table),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                TableUnionWithVectorStructSandwich,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            TableUnionWithVectorStructSandwichStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TableUnionWithVectorStructSandwichStruct>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TableUnionWithVectorStructSandwichStruct
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                table: fidl::new_empty!(
                    TableUnionWithVectorStructSandwich,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                TableUnionWithVectorStructSandwich,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.table,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for TableWithUnknownEnveloepsAfterKnownEnvelopesStruct {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TableWithUnknownEnveloepsAfterKnownEnvelopesStruct {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            TableWithUnknownEnveloepsAfterKnownEnvelopesStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut TableWithUnknownEnveloepsAfterKnownEnvelopesStruct
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<TableWithUnknownEnveloepsAfterKnownEnvelopesStruct>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<TableWithUnknownEnveloepsAfterKnownEnvelopesStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <TableWithUnknownEnvelopesAfterKnownEnvelopes as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.t),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                TableWithUnknownEnvelopesAfterKnownEnvelopes,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            TableWithUnknownEnveloepsAfterKnownEnvelopesStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<TableWithUnknownEnveloepsAfterKnownEnvelopesStruct>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TableWithUnknownEnveloepsAfterKnownEnvelopesStruct
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                t: fidl::new_empty!(
                    TableWithUnknownEnvelopesAfterKnownEnvelopes,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                TableWithUnknownEnvelopesAfterKnownEnvelopes,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.t,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <TableWithUnknownEnvelopesBeforeKnownEnvelopes as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.t),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                TableWithUnknownEnvelopesBeforeKnownEnvelopes,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TableWithUnknownEnvelopesBeforeKnownEnvelopesStruct
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                t: fidl::new_empty!(
                    TableWithUnknownEnvelopesBeforeKnownEnvelopes,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                TableWithUnknownEnvelopesBeforeKnownEnvelopes,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.t,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for TestFlexibleResourceXUnionInStruct {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TestFlexibleResourceXUnionInStruct {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            TestFlexibleResourceXUnionInStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut TestFlexibleResourceXUnionInStruct
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TestFlexibleResourceXUnionInStruct>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                TestFlexibleResourceXUnionInStruct,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<SampleResourceXUnion as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.xu,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<SampleResourceXUnion, fidl::encoding::DefaultFuchsiaResourceDialect>,
    >
        fidl::encoding::Encode<
            TestFlexibleResourceXUnionInStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TestFlexibleResourceXUnionInStruct>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TestFlexibleResourceXUnionInStruct
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                xu: fidl::new_empty!(
                    SampleResourceXUnion,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                SampleResourceXUnion,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.xu,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for TestOptionalFlexibleResourceXUnionInStruct {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TestOptionalFlexibleResourceXUnionInStruct {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            TestOptionalFlexibleResourceXUnionInStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut TestOptionalFlexibleResourceXUnionInStruct
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TestOptionalFlexibleResourceXUnionInStruct>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<TestOptionalFlexibleResourceXUnionInStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::OptionalUnion<SampleResourceXUnion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.xu),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::OptionalUnion<SampleResourceXUnion>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            TestOptionalFlexibleResourceXUnionInStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TestOptionalFlexibleResourceXUnionInStruct>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TestOptionalFlexibleResourceXUnionInStruct
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                xu: fidl::new_empty!(
                    fidl::encoding::OptionalUnion<SampleResourceXUnion>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::OptionalUnion<SampleResourceXUnion>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.xu,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for TestOptionalStrictResourceXUnionInStruct {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TestOptionalStrictResourceXUnionInStruct {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            TestOptionalStrictResourceXUnionInStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut TestOptionalStrictResourceXUnionInStruct
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TestOptionalStrictResourceXUnionInStruct>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<TestOptionalStrictResourceXUnionInStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::OptionalUnion<SampleStrictResourceXUnion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.xu),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::OptionalUnion<SampleStrictResourceXUnion>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            TestOptionalStrictResourceXUnionInStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TestOptionalStrictResourceXUnionInStruct>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TestOptionalStrictResourceXUnionInStruct
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                xu: fidl::new_empty!(
                    fidl::encoding::OptionalUnion<SampleStrictResourceXUnion>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::OptionalUnion<SampleStrictResourceXUnion>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.xu,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for TestPackageResolverResolveRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TestPackageResolverResolveRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            40
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            TestPackageResolverResolveRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut TestPackageResolverResolveRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TestPackageResolverResolveRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<TestPackageResolverResolveRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(&self.package_url),
                    <fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow(&self.selectors),
                    <UpdatePolicy as fidl::encoding::ValueTypeMarker>::borrow(&self.update_policy),
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(&self.this_should_be_a_handle),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::UnboundedString,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<UpdatePolicy, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T3: fidl::encoding::Encode<u32, fidl::encoding::DefaultFuchsiaResourceDialect>,
    >
        fidl::encoding::Encode<
            TestPackageResolverResolveRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TestPackageResolverResolveRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            self.3.encode(encoder, offset + 36, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TestPackageResolverResolveRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                package_url: fidl::new_empty!(
                    fidl::encoding::UnboundedString,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                selectors: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                update_policy: fidl::new_empty!(
                    UpdatePolicy,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                this_should_be_a_handle: fidl::new_empty!(
                    u32,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffff0000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::UnboundedString,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.package_url,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.selectors,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                UpdatePolicy,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.update_policy,
                decoder,
                offset + 32,
                _depth
            )?;
            fidl::decode!(
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.this_should_be_a_handle,
                decoder,
                offset + 36,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for TestStrictResourceXUnionInStruct {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TestStrictResourceXUnionInStruct {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            TestStrictResourceXUnionInStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut TestStrictResourceXUnionInStruct
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TestStrictResourceXUnionInStruct>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<TestStrictResourceXUnionInStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <SampleStrictResourceXUnion as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.xu),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                SampleStrictResourceXUnion,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            TestStrictResourceXUnionInStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TestStrictResourceXUnionInStruct>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TestStrictResourceXUnionInStruct
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                xu: fidl::new_empty!(
                    SampleStrictResourceXUnion,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                SampleStrictResourceXUnion,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.xu,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for UnboundedNonnullableVectorOfHandles {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for UnboundedNonnullableVectorOfHandles {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            UnboundedNonnullableVectorOfHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut UnboundedNonnullableVectorOfHandles
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UnboundedNonnullableVectorOfHandles>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                UnboundedNonnullableVectorOfHandles,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::UnboundedVector<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.vh0
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            UnboundedNonnullableVectorOfHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UnboundedNonnullableVectorOfHandles>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for UnboundedNonnullableVectorOfHandles
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vh0: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::UnboundedVector<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.vh0,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for UnboundedNullableVectorOfHandles {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for UnboundedNullableVectorOfHandles {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            UnboundedNullableVectorOfHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut UnboundedNullableVectorOfHandles
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UnboundedNullableVectorOfHandles>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                UnboundedNullableVectorOfHandles,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Optional<
                    fidl::encoding::UnboundedVector<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    >,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.vh0
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::UnboundedVector<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            UnboundedNullableVectorOfHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UnboundedNullableVectorOfHandles>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for UnboundedNullableVectorOfHandles
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                vh0: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::UnboundedVector<
                            fidl::encoding::HandleType<
                                fidl::NullableHandle,
                                { fidl::ObjectType::NONE.into_raw() },
                                2147483648,
                            >,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::UnboundedVector<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.vh0,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for UnionOfEndpoints {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for UnionOfEndpoints {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<UnionOfEndpoints, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut UnionOfEndpoints
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UnionOfEndpoints>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<UnionOfEndpoints, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <UnionOfEndpointsUnion as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.u),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                UnionOfEndpointsUnion,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    > fidl::encoding::Encode<UnionOfEndpoints, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UnionOfEndpoints>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for UnionOfEndpoints
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                u: fidl::new_empty!(
                    UnionOfEndpointsUnion,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                UnionOfEndpointsUnion,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.u,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for VectorOfArrayOfEventInStructWithDefaultRights {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for VectorOfArrayOfEventInStructWithDefaultRights {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            VectorOfArrayOfEventInStructWithDefaultRights,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut VectorOfArrayOfEventInStructWithDefaultRights
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VectorOfArrayOfEventInStructWithDefaultRights>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                VectorOfArrayOfEventInStructWithDefaultRights,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Vector<
                    fidl::encoding::Array<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            53251,
                        >,
                        1,
                    >,
                    1,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.h
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Vector<
                    fidl::encoding::Array<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            53251,
                        >,
                        1,
                    >,
                    1,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            VectorOfArrayOfEventInStructWithDefaultRights,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VectorOfArrayOfEventInStructWithDefaultRights>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for VectorOfArrayOfEventInStructWithDefaultRights
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                h: fidl::new_empty!(
                    fidl::encoding::Vector<
                        fidl::encoding::Array<
                            fidl::encoding::HandleType<
                                fidl::Event,
                                { fidl::ObjectType::EVENT.into_raw() },
                                53251,
                            >,
                            1,
                        >,
                        1,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Vector<
                    fidl::encoding::Array<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            53251,
                        >,
                        1,
                    >,
                    1,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.h,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for VectorOfArrayOfEventInStructWithReducedRights {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for VectorOfArrayOfEventInStructWithReducedRights {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            VectorOfArrayOfEventInStructWithReducedRights,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut VectorOfArrayOfEventInStructWithReducedRights
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VectorOfArrayOfEventInStructWithReducedRights>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                VectorOfArrayOfEventInStructWithReducedRights,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Vector<
                    fidl::encoding::Array<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            49155,
                        >,
                        1,
                    >,
                    1,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.h
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Vector<
                    fidl::encoding::Array<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            49155,
                        >,
                        1,
                    >,
                    1,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            VectorOfArrayOfEventInStructWithReducedRights,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VectorOfArrayOfEventInStructWithReducedRights>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for VectorOfArrayOfEventInStructWithReducedRights
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                h: fidl::new_empty!(
                    fidl::encoding::Vector<
                        fidl::encoding::Array<
                            fidl::encoding::HandleType<
                                fidl::Event,
                                { fidl::ObjectType::EVENT.into_raw() },
                                49155,
                            >,
                            1,
                        >,
                        1,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Vector<
                    fidl::encoding::Array<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            49155,
                        >,
                        1,
                    >,
                    1,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.h,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for VectorOfArrayOfEventInTableWithReducedRightsStruct {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for VectorOfArrayOfEventInTableWithReducedRightsStruct {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            VectorOfArrayOfEventInTableWithReducedRightsStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut VectorOfArrayOfEventInTableWithReducedRightsStruct
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<VectorOfArrayOfEventInTableWithReducedRightsStruct>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<VectorOfArrayOfEventInTableWithReducedRightsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <VectorOfArrayOfEventInTableWithReducedRights as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.t),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                VectorOfArrayOfEventInTableWithReducedRights,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            VectorOfArrayOfEventInTableWithReducedRightsStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<VectorOfArrayOfEventInTableWithReducedRightsStruct>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for VectorOfArrayOfEventInTableWithReducedRightsStruct
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                t: fidl::new_empty!(
                    VectorOfArrayOfEventInTableWithReducedRights,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                VectorOfArrayOfEventInTableWithReducedRights,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.t,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for VectorOfArrayOfEventInUnionWithReducedRightsStruct {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for VectorOfArrayOfEventInUnionWithReducedRightsStruct {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            VectorOfArrayOfEventInUnionWithReducedRightsStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut VectorOfArrayOfEventInUnionWithReducedRightsStruct
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<VectorOfArrayOfEventInUnionWithReducedRightsStruct>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<VectorOfArrayOfEventInUnionWithReducedRightsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <VectorOfArrayOfEventInUnionWithReducedRights as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.u),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                VectorOfArrayOfEventInUnionWithReducedRights,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            VectorOfArrayOfEventInUnionWithReducedRightsStruct,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<VectorOfArrayOfEventInUnionWithReducedRightsStruct>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for VectorOfArrayOfEventInUnionWithReducedRightsStruct
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                u: fidl::new_empty!(
                    VectorOfArrayOfEventInUnionWithReducedRights,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                VectorOfArrayOfEventInUnionWithReducedRights,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.u,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for VectorOfHandles {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for VectorOfHandles {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<VectorOfHandles, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut VectorOfHandles
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VectorOfHandles>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<VectorOfHandles, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::UnboundedVector<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.v),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    > fidl::encoding::Encode<VectorOfHandles, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VectorOfHandles>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for VectorOfHandles
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                v: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::UnboundedVector<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.v,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for VectorOfOptionalHandles {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for VectorOfOptionalHandles {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            VectorOfOptionalHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut VectorOfOptionalHandles
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VectorOfOptionalHandles>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                VectorOfOptionalHandles,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::UnboundedVector<
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    >,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.v
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            VectorOfOptionalHandles,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VectorOfOptionalHandles>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for VectorOfOptionalHandles
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                v: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<
                        fidl::encoding::Optional<
                            fidl::encoding::HandleType<
                                fidl::NullableHandle,
                                { fidl::ObjectType::NONE.into_raw() },
                                2147483648,
                            >,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::UnboundedVector<
                    fidl::encoding::Optional<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.v,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for VectorOfUpTo2Handles {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for VectorOfUpTo2Handles {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<VectorOfUpTo2Handles, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut VectorOfUpTo2Handles
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VectorOfUpTo2Handles>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                VectorOfUpTo2Handles,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Vector<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                    2,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.v
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Vector<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                    2,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<VectorOfUpTo2Handles, fidl::encoding::DefaultFuchsiaResourceDialect>
        for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VectorOfUpTo2Handles>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for VectorOfUpTo2Handles
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                v: fidl::new_empty!(
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                        2,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Vector<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                    2,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.v,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl ArrayOfVectorOfEventInTableWithDefaultRights {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.h {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ArrayOfVectorOfEventInTableWithDefaultRights {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ArrayOfVectorOfEventInTableWithDefaultRights {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ArrayOfVectorOfEventInTableWithDefaultRights,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ArrayOfVectorOfEventInTableWithDefaultRights
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ArrayOfVectorOfEventInTableWithDefaultRights>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::Array<
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            53251,
                        >,
                        1,
                    >,
                    1,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.h.as_mut().map(
                    <fidl::encoding::Array<
                        fidl::encoding::Vector<
                            fidl::encoding::HandleType<
                                fidl::Event,
                                { fidl::ObjectType::EVENT.into_raw() },
                                53251,
                            >,
                            1,
                        >,
                        1,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ArrayOfVectorOfEventInTableWithDefaultRights
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Array<
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            53251,
                        >,
                        1,
                    >,
                    1,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.h.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Array<
                            fidl::encoding::Vector<
                                fidl::encoding::HandleType<
                                    fidl::Event,
                                    { fidl::ObjectType::EVENT.into_raw() },
                                    53251,
                                >,
                                1,
                            >,
                            1,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Array<
                        fidl::encoding::Vector<
                            fidl::encoding::HandleType<
                                fidl::Event,
                                { fidl::ObjectType::EVENT.into_raw() },
                                53251,
                            >,
                            1,
                        >,
                        1,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl ArrayOfVectorOfEventInTableWithReducedRights {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.h {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ArrayOfVectorOfEventInTableWithReducedRights {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ArrayOfVectorOfEventInTableWithReducedRights {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ArrayOfVectorOfEventInTableWithReducedRights,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ArrayOfVectorOfEventInTableWithReducedRights
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ArrayOfVectorOfEventInTableWithReducedRights>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::Array<
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            49155,
                        >,
                        1,
                    >,
                    1,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.h.as_mut().map(
                    <fidl::encoding::Array<
                        fidl::encoding::Vector<
                            fidl::encoding::HandleType<
                                fidl::Event,
                                { fidl::ObjectType::EVENT.into_raw() },
                                49155,
                            >,
                            1,
                        >,
                        1,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ArrayOfVectorOfEventInTableWithReducedRights
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Array<
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            49155,
                        >,
                        1,
                    >,
                    1,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.h.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Array<
                            fidl::encoding::Vector<
                                fidl::encoding::HandleType<
                                    fidl::Event,
                                    { fidl::ObjectType::EVENT.into_raw() },
                                    49155,
                                >,
                                1,
                            >,
                            1,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Array<
                        fidl::encoding::Vector<
                            fidl::encoding::HandleType<
                                fidl::Event,
                                { fidl::ObjectType::EVENT.into_raw() },
                                49155,
                            >,
                            1,
                        >,
                        1,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl EmptyResourceTable {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for EmptyResourceTable {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for EmptyResourceTable {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<EmptyResourceTable, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut EmptyResourceTable
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EmptyResourceTable>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for EmptyResourceTable
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl SimpleResourceTable {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.y {
                return 5;
            }
            if let Some(_) = self.x {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for SimpleResourceTable {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for SimpleResourceTable {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<SimpleResourceTable, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut SimpleResourceTable
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SimpleResourceTable>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                i64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.x.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 5 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (5 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                i64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.y.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for SimpleResourceTable
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.x.get_or_insert_with(|| {
                    fidl::new_empty!(i64, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    i64,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 5 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.y.get_or_insert_with(|| {
                    fidl::new_empty!(i64, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    i64,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl TableFieldInlinedHandle {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.f {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for TableFieldInlinedHandle {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TableFieldInlinedHandle {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            TableFieldInlinedHandle,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut TableFieldInlinedHandle
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TableFieldInlinedHandle>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::HandleType<
                    fidl::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.f.as_mut().map(
                    <fidl::encoding::HandleType<
                        fidl::Channel,
                        { fidl::ObjectType::CHANNEL.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TableFieldInlinedHandle
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::HandleType<
                    fidl::Channel,
                    { fidl::ObjectType::CHANNEL.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.f.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fidl::Channel, { fidl::ObjectType::CHANNEL.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl TableFieldUnknownResource {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for TableFieldUnknownResource {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TableFieldUnknownResource {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            TableFieldUnknownResource,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut TableFieldUnknownResource
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TableFieldUnknownResource>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TableFieldUnknownResource
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl TableOfEndpointsTable {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.server_end {
                return 2;
            }
            if let Some(_) = self.client_end {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for TableOfEndpointsTable {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TableOfEndpointsTable {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<TableOfEndpointsTable, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut TableOfEndpointsTable
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TableOfEndpointsTable>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ProtocolMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.client_end.as_mut().map(<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ProtocolMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProtocolMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.server_end.as_mut().map(<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProtocolMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TableOfEndpointsTable
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<ProtocolMarker>,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.client_end.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ProtocolMarker>>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ProtocolMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<ProtocolMarker>,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.server_end.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProtocolMarker>>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProtocolMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl TableUnionWithVectorReservedSandwich {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.uv {
                return 2;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for TableUnionWithVectorReservedSandwich {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TableUnionWithVectorReservedSandwich {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            TableUnionWithVectorReservedSandwich,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut TableUnionWithVectorReservedSandwich
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TableUnionWithVectorReservedSandwich>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                UnionWithVector,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.uv
                    .as_mut()
                    .map(<UnionWithVector as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TableUnionWithVectorReservedSandwich
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <UnionWithVector as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.uv.get_or_insert_with(|| {
                    fidl::new_empty!(UnionWithVector, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    UnionWithVector,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl TableUnionWithVectorStructSandwich {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.s2 {
                return 3;
            }
            if let Some(_) = self.uv {
                return 2;
            }
            if let Some(_) = self.s1 {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for TableUnionWithVectorStructSandwich {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TableUnionWithVectorStructSandwich {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            TableUnionWithVectorStructSandwich,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut TableUnionWithVectorStructSandwich
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TableUnionWithVectorStructSandwich>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                StructSize3Align1,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.s1
                    .as_ref()
                    .map(<StructSize3Align1 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                UnionWithVector,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.uv
                    .as_mut()
                    .map(<UnionWithVector as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 3 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (3 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                StructSize3Align1,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.s2
                    .as_ref()
                    .map(<StructSize3Align1 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TableUnionWithVectorStructSandwich
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <StructSize3Align1 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.s1.get_or_insert_with(|| {
                    fidl::new_empty!(
                        StructSize3Align1,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    StructSize3Align1,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <UnionWithVector as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.uv.get_or_insert_with(|| {
                    fidl::new_empty!(UnionWithVector, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    UnionWithVector,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 3 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <StructSize3Align1 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.s2.get_or_insert_with(|| {
                    fidl::new_empty!(
                        StructSize3Align1,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    StructSize3Align1,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl TableWithUnknownEnvelopesAfterKnownEnvelopes {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.a {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for TableWithUnknownEnvelopesAfterKnownEnvelopes {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TableWithUnknownEnvelopesAfterKnownEnvelopes {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            TableWithUnknownEnvelopesAfterKnownEnvelopes,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut TableWithUnknownEnvelopesAfterKnownEnvelopes
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TableWithUnknownEnvelopesAfterKnownEnvelopes>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::HandleType<
                    fidl::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    53251,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.a.as_mut().map(
                    <fidl::encoding::HandleType<
                        fidl::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        53251,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TableWithUnknownEnvelopesAfterKnownEnvelopes
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::HandleType<
                    fidl::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    53251,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.a.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 53251>, fidl::encoding::DefaultFuchsiaResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 53251>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl TableWithUnknownEnvelopesBeforeKnownEnvelopes {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.b {
                return 2;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for TableWithUnknownEnvelopesBeforeKnownEnvelopes {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TableWithUnknownEnvelopesBeforeKnownEnvelopes {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            TableWithUnknownEnvelopesBeforeKnownEnvelopes,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut TableWithUnknownEnvelopesBeforeKnownEnvelopes
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TableWithUnknownEnvelopesBeforeKnownEnvelopes>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::HandleType<
                    fidl::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    53251,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.b.as_mut().map(
                    <fidl::encoding::HandleType<
                        fidl::Event,
                        { fidl::ObjectType::EVENT.into_raw() },
                        53251,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for TableWithUnknownEnvelopesBeforeKnownEnvelopes
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::HandleType<
                    fidl::Event,
                    { fidl::ObjectType::EVENT.into_raw() },
                    53251,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.b.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 53251>, fidl::encoding::DefaultFuchsiaResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 53251>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl VectorOfArrayOfEventInTableWithReducedRights {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.h {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for VectorOfArrayOfEventInTableWithReducedRights {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for VectorOfArrayOfEventInTableWithReducedRights {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            VectorOfArrayOfEventInTableWithReducedRights,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut VectorOfArrayOfEventInTableWithReducedRights
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VectorOfArrayOfEventInTableWithReducedRights>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::Vector<
                    fidl::encoding::Array<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            49155,
                        >,
                        1,
                    >,
                    1,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.h.as_mut().map(
                    <fidl::encoding::Vector<
                        fidl::encoding::Array<
                            fidl::encoding::HandleType<
                                fidl::Event,
                                { fidl::ObjectType::EVENT.into_raw() },
                                49155,
                            >,
                            1,
                        >,
                        1,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for VectorOfArrayOfEventInTableWithReducedRights
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Vector<
                    fidl::encoding::Array<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            49155,
                        >,
                        1,
                    >,
                    1,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.h.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Vector<
                            fidl::encoding::Array<
                                fidl::encoding::HandleType<
                                    fidl::Event,
                                    { fidl::ObjectType::EVENT.into_raw() },
                                    49155,
                                >,
                                1,
                            >,
                            1,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Vector<
                        fidl::encoding::Array<
                            fidl::encoding::HandleType<
                                fidl::Event,
                                { fidl::ObjectType::EVENT.into_raw() },
                                49155,
                            >,
                            1,
                        >,
                        1,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ArrayOfVectorOfEventInUnionWithDefaultRights {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ArrayOfVectorOfEventInUnionWithDefaultRights {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ArrayOfVectorOfEventInUnionWithDefaultRights,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ArrayOfVectorOfEventInUnionWithDefaultRights
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ArrayOfVectorOfEventInUnionWithDefaultRights>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                ArrayOfVectorOfEventInUnionWithDefaultRights::H(ref mut val) => {
                    fidl::encoding::encode_in_envelope::<
                        fidl::encoding::Array<
                            fidl::encoding::Vector<
                                fidl::encoding::HandleType<
                                    fidl::Event,
                                    { fidl::ObjectType::EVENT.into_raw() },
                                    53251,
                                >,
                                1,
                            >,
                            1,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect,
                    >(
                        <fidl::encoding::Array<
                            fidl::encoding::Vector<
                                fidl::encoding::HandleType<
                                    fidl::Event,
                                    { fidl::ObjectType::EVENT.into_raw() },
                                    53251,
                                >,
                                1,
                            >,
                            1,
                        > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                            val
                        ),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
            }
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ArrayOfVectorOfEventInUnionWithDefaultRights
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::H(fidl::new_empty!(
                fidl::encoding::Array<
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            53251,
                        >,
                        1,
                    >,
                    1,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect
            ))
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
                1 => <fidl::encoding::Array<
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            53251,
                        >,
                        1,
                    >,
                    1,
                > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                _ => return Err(fidl::Error::UnknownUnionTag),
            };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ArrayOfVectorOfEventInUnionWithDefaultRights::H(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ArrayOfVectorOfEventInUnionWithDefaultRights::H(fidl::new_empty!(
                            fidl::encoding::Array<
                                fidl::encoding::Vector<
                                    fidl::encoding::HandleType<
                                        fidl::Event,
                                        { fidl::ObjectType::EVENT.into_raw() },
                                        53251,
                                    >,
                                    1,
                                >,
                                1,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ArrayOfVectorOfEventInUnionWithDefaultRights::H(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::Array<
                                fidl::encoding::Vector<
                                    fidl::encoding::HandleType<
                                        fidl::Event,
                                        { fidl::ObjectType::EVENT.into_raw() },
                                        53251,
                                    >,
                                    1,
                                >,
                                1,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                ordinal => panic!("unexpected ordinal {:?}", ordinal),
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ArrayOfVectorOfEventInUnionWithReducedRights {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ArrayOfVectorOfEventInUnionWithReducedRights {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ArrayOfVectorOfEventInUnionWithReducedRights,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ArrayOfVectorOfEventInUnionWithReducedRights
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ArrayOfVectorOfEventInUnionWithReducedRights>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                ArrayOfVectorOfEventInUnionWithReducedRights::H(ref mut val) => {
                    fidl::encoding::encode_in_envelope::<
                        fidl::encoding::Array<
                            fidl::encoding::Vector<
                                fidl::encoding::HandleType<
                                    fidl::Event,
                                    { fidl::ObjectType::EVENT.into_raw() },
                                    49155,
                                >,
                                1,
                            >,
                            1,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect,
                    >(
                        <fidl::encoding::Array<
                            fidl::encoding::Vector<
                                fidl::encoding::HandleType<
                                    fidl::Event,
                                    { fidl::ObjectType::EVENT.into_raw() },
                                    49155,
                                >,
                                1,
                            >,
                            1,
                        > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                            val
                        ),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
            }
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ArrayOfVectorOfEventInUnionWithReducedRights
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::H(fidl::new_empty!(
                fidl::encoding::Array<
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            49155,
                        >,
                        1,
                    >,
                    1,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect
            ))
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
                1 => <fidl::encoding::Array<
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            49155,
                        >,
                        1,
                    >,
                    1,
                > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                _ => return Err(fidl::Error::UnknownUnionTag),
            };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ArrayOfVectorOfEventInUnionWithReducedRights::H(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ArrayOfVectorOfEventInUnionWithReducedRights::H(fidl::new_empty!(
                            fidl::encoding::Array<
                                fidl::encoding::Vector<
                                    fidl::encoding::HandleType<
                                        fidl::Event,
                                        { fidl::ObjectType::EVENT.into_raw() },
                                        49155,
                                    >,
                                    1,
                                >,
                                1,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ArrayOfVectorOfEventInUnionWithReducedRights::H(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::Array<
                                fidl::encoding::Vector<
                                    fidl::encoding::HandleType<
                                        fidl::Event,
                                        { fidl::ObjectType::EVENT.into_raw() },
                                        49155,
                                    >,
                                    1,
                                >,
                                1,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                ordinal => panic!("unexpected ordinal {:?}", ordinal),
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for EnvelopeInliningTestUnion {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for EnvelopeInliningTestUnion {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            EnvelopeInliningTestUnion,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut EnvelopeInliningTestUnion
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EnvelopeInliningTestUnion>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                EnvelopeInliningTestUnion::Small(ref val) => fidl::encoding::encode_in_envelope::<
                    u32,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                EnvelopeInliningTestUnion::Large(ref val) => fidl::encoding::encode_in_envelope::<
                    u64,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                EnvelopeInliningTestUnion::Handle(ref mut val) => {
                    fidl::encoding::encode_in_envelope::<
                        fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect,
                    >(
                        <fidl::encoding::HandleType<
                            fidl::NullableHandle,
                            { fidl::ObjectType::NONE.into_raw() },
                            2147483648,
                        > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                            val
                        ),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                EnvelopeInliningTestUnion::__SourceBreaking { .. } => {
                    Err(fidl::Error::UnknownUnionTag)
                }
            }
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for EnvelopeInliningTestUnion
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
                1 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                2 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                3 => <fidl::encoding::HandleType<
                    fidl::NullableHandle,
                    { fidl::ObjectType::NONE.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                0 => return Err(fidl::Error::UnknownUnionTag),
                _ => num_bytes as usize,
            };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let EnvelopeInliningTestUnion::Small(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EnvelopeInliningTestUnion::Small(fidl::new_empty!(
                            u32,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EnvelopeInliningTestUnion::Small(ref mut val) = self {
                        fidl::decode!(
                            u32,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let EnvelopeInliningTestUnion::Large(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EnvelopeInliningTestUnion::Large(fidl::new_empty!(
                            u64,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EnvelopeInliningTestUnion::Large(ref mut val) = self {
                        fidl::decode!(
                            u64,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let EnvelopeInliningTestUnion::Handle(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EnvelopeInliningTestUnion::Handle(
                            fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EnvelopeInliningTestUnion::Handle(ref mut val) = self {
                        fidl::decode!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self =
                        EnvelopeInliningTestUnion::__SourceBreaking { unknown_ordinal: ordinal };
                }
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for SampleResourceXUnion {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for SampleResourceXUnion {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<SampleResourceXUnion, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut SampleResourceXUnion
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SampleResourceXUnion>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                SampleResourceXUnion::U(ref val) => fidl::encoding::encode_in_envelope::<
                    u32,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                SampleResourceXUnion::Su(ref val) => fidl::encoding::encode_in_envelope::<
                    SimpleUnion,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <SimpleUnion as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                SampleResourceXUnion::St(ref val) => fidl::encoding::encode_in_envelope::<
                    SimpleTable,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <SimpleTable as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                SampleResourceXUnion::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
            }
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for SampleResourceXUnion
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
                1 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                2 => <SimpleUnion as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                3 => <SimpleTable as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                0 => return Err(fidl::Error::UnknownUnionTag),
                _ => num_bytes as usize,
            };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let SampleResourceXUnion::U(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = SampleResourceXUnion::U(fidl::new_empty!(
                            u32,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let SampleResourceXUnion::U(ref mut val) = self {
                        fidl::decode!(
                            u32,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let SampleResourceXUnion::Su(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = SampleResourceXUnion::Su(fidl::new_empty!(
                            SimpleUnion,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let SampleResourceXUnion::Su(ref mut val) = self {
                        fidl::decode!(
                            SimpleUnion,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let SampleResourceXUnion::St(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = SampleResourceXUnion::St(fidl::new_empty!(
                            SimpleTable,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let SampleResourceXUnion::St(ref mut val) = self {
                        fidl::decode!(
                            SimpleTable,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = SampleResourceXUnion::__SourceBreaking { unknown_ordinal: ordinal };
                }
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for SampleStrictResourceXUnion {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for SampleStrictResourceXUnion {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            SampleStrictResourceXUnion,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut SampleStrictResourceXUnion
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SampleStrictResourceXUnion>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                SampleStrictResourceXUnion::U(ref val) => fidl::encoding::encode_in_envelope::<
                    u32,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                SampleStrictResourceXUnion::Su(ref val) => fidl::encoding::encode_in_envelope::<
                    SimpleUnion,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <SimpleUnion as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                SampleStrictResourceXUnion::St(ref val) => fidl::encoding::encode_in_envelope::<
                    SimpleTable,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <SimpleTable as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
            }
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for SampleStrictResourceXUnion
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::U(fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect))
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
                1 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                2 => <SimpleUnion as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                3 => <SimpleTable as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                _ => return Err(fidl::Error::UnknownUnionTag),
            };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let SampleStrictResourceXUnion::U(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = SampleStrictResourceXUnion::U(fidl::new_empty!(
                            u32,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let SampleStrictResourceXUnion::U(ref mut val) = self {
                        fidl::decode!(
                            u32,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let SampleStrictResourceXUnion::Su(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = SampleStrictResourceXUnion::Su(fidl::new_empty!(
                            SimpleUnion,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let SampleStrictResourceXUnion::Su(ref mut val) = self {
                        fidl::decode!(
                            SimpleUnion,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let SampleStrictResourceXUnion::St(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = SampleStrictResourceXUnion::St(fidl::new_empty!(
                            SimpleTable,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let SampleStrictResourceXUnion::St(ref mut val) = self {
                        fidl::decode!(
                            SimpleTable,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                ordinal => panic!("unexpected ordinal {:?}", ordinal),
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for UnionOfEndpointsUnion {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for UnionOfEndpointsUnion {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<UnionOfEndpointsUnion, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut UnionOfEndpointsUnion
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UnionOfEndpointsUnion>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
            UnionOfEndpointsUnion::ClientEnd(ref mut val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ProtocolMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ProtocolMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            UnionOfEndpointsUnion::ServerEnd(ref mut val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProtocolMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProtocolMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            UnionOfEndpointsUnion::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
        }
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for UnionOfEndpointsUnion
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
            1 => <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ProtocolMarker>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            2 => <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProtocolMarker>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            0 => return Err(fidl::Error::UnknownUnionTag),
            _ => num_bytes as usize,
        };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let UnionOfEndpointsUnion::ClientEnd(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = UnionOfEndpointsUnion::ClientEnd(fidl::new_empty!(
                            fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ProtocolMarker>>,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let UnionOfEndpointsUnion::ClientEnd(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<ProtocolMarker>>,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let UnionOfEndpointsUnion::ServerEnd(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = UnionOfEndpointsUnion::ServerEnd(fidl::new_empty!(
                            fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProtocolMarker>>,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let UnionOfEndpointsUnion::ServerEnd(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ProtocolMarker>>,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = UnionOfEndpointsUnion::__SourceBreaking { unknown_ordinal: ordinal };
                }
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for UnionOfHandle {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for UnionOfHandle {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl fidl::encoding::Encode<UnionOfHandle, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut UnionOfHandle
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UnionOfHandle>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                UnionOfHandle::H(ref mut val) => fidl::encoding::encode_in_envelope::<
                    fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <fidl::encoding::HandleType<
                        fidl::NullableHandle,
                        { fidl::ObjectType::NONE.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        val
                    ),
                    encoder,
                    offset + 8,
                    _depth,
                ),
            }
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for UnionOfHandle {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::H(
                fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
            )
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
                1 => <fidl::encoding::HandleType<
                    fidl::NullableHandle,
                    { fidl::ObjectType::NONE.into_raw() },
                    2147483648,
                > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                _ => return Err(fidl::Error::UnknownUnionTag),
            };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let UnionOfHandle::H(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = UnionOfHandle::H(
                            fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let UnionOfHandle::H(ref mut val) = self {
                        fidl::decode!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                ordinal => panic!("unexpected ordinal {:?}", ordinal),
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for UnionWithVector {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for UnionWithVector {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<UnionWithVector, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut UnionWithVector
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UnionWithVector>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
            UnionWithVector::Unused(ref val) => {
                fidl::encoding::encode_in_envelope::<u8, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            UnionWithVector::VectorOfUint8(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            UnionWithVector::S(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedString, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            UnionWithVector::VectorS3A1(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<StructSize3Align1>, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::UnboundedVector<StructSize3Align1> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            UnionWithVector::VectorS3A2(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<StructSize3Align2>, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::UnboundedVector<StructSize3Align2> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            UnionWithVector::Handles(ref mut val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::UnboundedVector<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            UnionWithVector::ArrayS3A1(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Array<StructSize3Align1, 2>, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::Array<StructSize3Align1, 2> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            UnionWithVector::ArrayS3A2(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Array<StructSize3Align2, 2>, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::Array<StructSize3Align2, 2> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            UnionWithVector::VectorUnion(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<UnionSize8Align4>, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::UnboundedVector<UnionSize8Align4> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
        }
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for UnionWithVector
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Unused(fidl::new_empty!(u8, fidl::encoding::DefaultFuchsiaResourceDialect))
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
            1 => <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            2 => <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            3 => <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            4 => <fidl::encoding::UnboundedVector<StructSize3Align1> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            5 => <fidl::encoding::UnboundedVector<StructSize3Align2> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            6 => <fidl::encoding::UnboundedVector<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            7 => <fidl::encoding::Array<StructSize3Align1, 2> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            8 => <fidl::encoding::Array<StructSize3Align2, 2> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            9 => <fidl::encoding::UnboundedVector<UnionSize8Align4> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            _ => return Err(fidl::Error::UnknownUnionTag),
        };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let UnionWithVector::Unused(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = UnionWithVector::Unused(fidl::new_empty!(
                            u8,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let UnionWithVector::Unused(ref mut val) = self {
                        fidl::decode!(
                            u8,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let UnionWithVector::VectorOfUint8(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = UnionWithVector::VectorOfUint8(fidl::new_empty!(
                            fidl::encoding::UnboundedVector<u8>,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let UnionWithVector::VectorOfUint8(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::UnboundedVector<u8>,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let UnionWithVector::S(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = UnionWithVector::S(fidl::new_empty!(
                            fidl::encoding::UnboundedString,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let UnionWithVector::S(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::UnboundedString,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                4 => {
                    #[allow(irrefutable_let_patterns)]
                    if let UnionWithVector::VectorS3A1(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = UnionWithVector::VectorS3A1(fidl::new_empty!(
                            fidl::encoding::UnboundedVector<StructSize3Align1>,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let UnionWithVector::VectorS3A1(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::UnboundedVector<StructSize3Align1>,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                5 => {
                    #[allow(irrefutable_let_patterns)]
                    if let UnionWithVector::VectorS3A2(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = UnionWithVector::VectorS3A2(fidl::new_empty!(
                            fidl::encoding::UnboundedVector<StructSize3Align2>,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let UnionWithVector::VectorS3A2(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::UnboundedVector<StructSize3Align2>,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                6 => {
                    #[allow(irrefutable_let_patterns)]
                    if let UnionWithVector::Handles(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = UnionWithVector::Handles(fidl::new_empty!(
                            fidl::encoding::UnboundedVector<
                                fidl::encoding::HandleType<
                                    fidl::NullableHandle,
                                    { fidl::ObjectType::NONE.into_raw() },
                                    2147483648,
                                >,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let UnionWithVector::Handles(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::UnboundedVector<
                                fidl::encoding::HandleType<
                                    fidl::NullableHandle,
                                    { fidl::ObjectType::NONE.into_raw() },
                                    2147483648,
                                >,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                7 => {
                    #[allow(irrefutable_let_patterns)]
                    if let UnionWithVector::ArrayS3A1(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = UnionWithVector::ArrayS3A1(
                            fidl::new_empty!(fidl::encoding::Array<StructSize3Align1, 2>, fidl::encoding::DefaultFuchsiaResourceDialect),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let UnionWithVector::ArrayS3A1(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Array<StructSize3Align1, 2>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                8 => {
                    #[allow(irrefutable_let_patterns)]
                    if let UnionWithVector::ArrayS3A2(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = UnionWithVector::ArrayS3A2(
                            fidl::new_empty!(fidl::encoding::Array<StructSize3Align2, 2>, fidl::encoding::DefaultFuchsiaResourceDialect),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let UnionWithVector::ArrayS3A2(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Array<StructSize3Align2, 2>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                9 => {
                    #[allow(irrefutable_let_patterns)]
                    if let UnionWithVector::VectorUnion(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = UnionWithVector::VectorUnion(fidl::new_empty!(
                            fidl::encoding::UnboundedVector<UnionSize8Align4>,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let UnionWithVector::VectorUnion(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::UnboundedVector<UnionSize8Align4>,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                ordinal => panic!("unexpected ordinal {:?}", ordinal),
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for VectorOfArrayOfEventInUnionWithReducedRights {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for VectorOfArrayOfEventInUnionWithReducedRights {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            VectorOfArrayOfEventInUnionWithReducedRights,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut VectorOfArrayOfEventInUnionWithReducedRights
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<VectorOfArrayOfEventInUnionWithReducedRights>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                VectorOfArrayOfEventInUnionWithReducedRights::H(ref mut val) => {
                    fidl::encoding::encode_in_envelope::<
                        fidl::encoding::Vector<
                            fidl::encoding::Array<
                                fidl::encoding::HandleType<
                                    fidl::Event,
                                    { fidl::ObjectType::EVENT.into_raw() },
                                    49155,
                                >,
                                1,
                            >,
                            1,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect,
                    >(
                        <fidl::encoding::Vector<
                            fidl::encoding::Array<
                                fidl::encoding::HandleType<
                                    fidl::Event,
                                    { fidl::ObjectType::EVENT.into_raw() },
                                    49155,
                                >,
                                1,
                            >,
                            1,
                        > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                            val
                        ),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
            }
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for VectorOfArrayOfEventInUnionWithReducedRights
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::H(fidl::new_empty!(
                fidl::encoding::Vector<
                    fidl::encoding::Array<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            49155,
                        >,
                        1,
                    >,
                    1,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect
            ))
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
                1 => <fidl::encoding::Vector<
                    fidl::encoding::Array<
                        fidl::encoding::HandleType<
                            fidl::Event,
                            { fidl::ObjectType::EVENT.into_raw() },
                            49155,
                        >,
                        1,
                    >,
                    1,
                > as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                _ => return Err(fidl::Error::UnknownUnionTag),
            };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let VectorOfArrayOfEventInUnionWithReducedRights::H(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = VectorOfArrayOfEventInUnionWithReducedRights::H(fidl::new_empty!(
                            fidl::encoding::Vector<
                                fidl::encoding::Array<
                                    fidl::encoding::HandleType<
                                        fidl::Event,
                                        { fidl::ObjectType::EVENT.into_raw() },
                                        49155,
                                    >,
                                    1,
                                >,
                                1,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let VectorOfArrayOfEventInUnionWithReducedRights::H(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::Vector<
                                fidl::encoding::Array<
                                    fidl::encoding::HandleType<
                                        fidl::Event,
                                        { fidl::ObjectType::EVENT.into_raw() },
                                        49155,
                                    >,
                                    1,
                                >,
                                1,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                ordinal => panic!("unexpected ordinal {:?}", ordinal),
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }
}