fidl_fidl_clientsuite__common/

fidl_fidl_clientsuite__common.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::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

pub const CLIENT_SUITE_VERSION: u64 = 1;

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum FidlErrorKind {
    OtherError = 1,
    DecodingError = 2,
    ChannelPeerClosed = 3,
    UnknownMethod = 4,
    UnexpectedMessage = 5,
}

impl FidlErrorKind {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::OtherError),
            2 => Some(Self::DecodingError),
            3 => Some(Self::ChannelPeerClosed),
            4 => Some(Self::UnknownMethod),
            5 => Some(Self::UnexpectedMessage),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum IoStyle {
    Sync = 1,
    Async = 2,
}

impl IoStyle {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::Sync),
            2 => Some(Self::Async),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum Test {
    Setup,
    TwoWayNoPayload,
    TwoWayStructPayload,
    TwoWayTablePayload,
    TwoWayUnionPayload,
    TwoWayResultWithPayload,
    TwoWayResultWithError,
    TwoWayStructRequest,
    TwoWayTableRequest,
    TwoWayUnionRequest,
    OneWayNoRequest,
    OneWayStructRequest,
    OneWayTableRequest,
    OneWayUnionRequest,
    ReceiveEventNoPayload,
    ReceiveEventStructPayload,
    ReceiveEventTablePayload,
    ReceiveEventUnionPayload,
    GracefulFailureDuringCallAfterPeerClose,
    ReceiveEventBadMagicNumber,
    ReceiveEventUnexpectedTxid,
    ReceiveEventUnknownOrdinal,
    ReceiveResponseBadMagicNumber,
    ReceiveResponseUnexpectedTxid,
    ReceiveResponseWrongOrdinalKnown,
    ReceiveResponseWrongOrdinalUnknown,
    V1TwoWayNoPayload,
    V1TwoWayStructPayload,
    OneWayCallDoNotReportPeerClosed,
    OneWayStrictSend,
    OneWayFlexibleSend,
    TwoWayStrictSend,
    TwoWayStrictSendMismatchedStrictness,
    TwoWayStrictSendNonEmptyPayload,
    TwoWayStrictErrorSyntaxSendSuccessResponse,
    TwoWayStrictErrorSyntaxSendErrorResponse,
    TwoWayStrictErrorSyntaxSendUnknownMethodResponse,
    TwoWayStrictErrorSyntaxSendMismatchedStrictnessUnknownMethodResponse,
    TwoWayStrictErrorSyntaxSendNonEmptyPayload,
    TwoWayFlexibleSendSuccessResponse,
    TwoWayFlexibleSendErrorResponse,
    TwoWayFlexibleSendUnknownMethodResponse,
    TwoWayFlexibleSendMismatchedStrictnessUnknownMethodResponse,
    TwoWayFlexibleSendOtherFrameworkErrResponse,
    TwoWayFlexibleSendNonEmptyPayloadSuccessResponse,
    TwoWayFlexibleSendNonEmptyPayloadUnknownMethodResponse,
    TwoWayFlexibleErrorSyntaxSendSuccessResponse,
    TwoWayFlexibleErrorSyntaxSendErrorResponse,
    TwoWayFlexibleErrorSyntaxSendUnknownMethodResponse,
    TwoWayFlexibleErrorSyntaxSendMismatchedStrictnessUnknownMethodResponse,
    TwoWayFlexibleErrorSyntaxSendOtherFrameworkErrResponse,
    TwoWayFlexibleErrorSyntaxSendNonEmptyPayloadSuccessResponse,
    TwoWayFlexibleErrorSyntaxSendNonEmptyPayloadUnknownMethodResponse,
    ReceiveStrictEvent,
    ReceiveStrictEventMismatchedStrictness,
    ReceiveFlexibleEvent,
    ReceiveFlexibleEventMismatchedStrictness,
    UnknownStrictEventOpenProtocol,
    UnknownFlexibleEventOpenProtocol,
    UnknownStrictEventAjarProtocol,
    UnknownFlexibleEventAjarProtocol,
    UnknownStrictEventClosedProtocol,
    UnknownFlexibleEventClosedProtocol,
    UnknownStrictServerInitiatedTwoWay,
    UnknownFlexibleServerInitiatedTwoWay,
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u32,
    },
}

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

impl Test {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::Setup),
            2 => Some(Self::TwoWayNoPayload),
            42 => Some(Self::TwoWayStructPayload),
            43 => Some(Self::TwoWayTablePayload),
            44 => Some(Self::TwoWayUnionPayload),
            45 => Some(Self::TwoWayResultWithPayload),
            46 => Some(Self::TwoWayResultWithError),
            52 => Some(Self::TwoWayStructRequest),
            53 => Some(Self::TwoWayTableRequest),
            54 => Some(Self::TwoWayUnionRequest),
            48 => Some(Self::OneWayNoRequest),
            49 => Some(Self::OneWayStructRequest),
            50 => Some(Self::OneWayTableRequest),
            51 => Some(Self::OneWayUnionRequest),
            55 => Some(Self::ReceiveEventNoPayload),
            56 => Some(Self::ReceiveEventStructPayload),
            57 => Some(Self::ReceiveEventTablePayload),
            58 => Some(Self::ReceiveEventUnionPayload),
            3 => Some(Self::GracefulFailureDuringCallAfterPeerClose),
            60 => Some(Self::ReceiveEventBadMagicNumber),
            61 => Some(Self::ReceiveEventUnexpectedTxid),
            62 => Some(Self::ReceiveEventUnknownOrdinal),
            63 => Some(Self::ReceiveResponseBadMagicNumber),
            64 => Some(Self::ReceiveResponseUnexpectedTxid),
            65 => Some(Self::ReceiveResponseWrongOrdinalKnown),
            67 => Some(Self::ReceiveResponseWrongOrdinalUnknown),
            40 => Some(Self::V1TwoWayNoPayload),
            41 => Some(Self::V1TwoWayStructPayload),
            59 => Some(Self::OneWayCallDoNotReportPeerClosed),
            4 => Some(Self::OneWayStrictSend),
            5 => Some(Self::OneWayFlexibleSend),
            6 => Some(Self::TwoWayStrictSend),
            7 => Some(Self::TwoWayStrictSendMismatchedStrictness),
            38 => Some(Self::TwoWayStrictSendNonEmptyPayload),
            8 => Some(Self::TwoWayStrictErrorSyntaxSendSuccessResponse),
            9 => Some(Self::TwoWayStrictErrorSyntaxSendErrorResponse),
            10 => Some(Self::TwoWayStrictErrorSyntaxSendUnknownMethodResponse),
            11 => Some(Self::TwoWayStrictErrorSyntaxSendMismatchedStrictnessUnknownMethodResponse),
            39 => Some(Self::TwoWayStrictErrorSyntaxSendNonEmptyPayload),
            12 => Some(Self::TwoWayFlexibleSendSuccessResponse),
            13 => Some(Self::TwoWayFlexibleSendErrorResponse),
            14 => Some(Self::TwoWayFlexibleSendUnknownMethodResponse),
            15 => Some(Self::TwoWayFlexibleSendMismatchedStrictnessUnknownMethodResponse),
            16 => Some(Self::TwoWayFlexibleSendOtherFrameworkErrResponse),
            17 => Some(Self::TwoWayFlexibleSendNonEmptyPayloadSuccessResponse),
            18 => Some(Self::TwoWayFlexibleSendNonEmptyPayloadUnknownMethodResponse),
            19 => Some(Self::TwoWayFlexibleErrorSyntaxSendSuccessResponse),
            20 => Some(Self::TwoWayFlexibleErrorSyntaxSendErrorResponse),
            21 => Some(Self::TwoWayFlexibleErrorSyntaxSendUnknownMethodResponse),
            22 => {
                Some(Self::TwoWayFlexibleErrorSyntaxSendMismatchedStrictnessUnknownMethodResponse)
            }
            23 => Some(Self::TwoWayFlexibleErrorSyntaxSendOtherFrameworkErrResponse),
            24 => Some(Self::TwoWayFlexibleErrorSyntaxSendNonEmptyPayloadSuccessResponse),
            25 => Some(Self::TwoWayFlexibleErrorSyntaxSendNonEmptyPayloadUnknownMethodResponse),
            26 => Some(Self::ReceiveStrictEvent),
            27 => Some(Self::ReceiveStrictEventMismatchedStrictness),
            28 => Some(Self::ReceiveFlexibleEvent),
            29 => Some(Self::ReceiveFlexibleEventMismatchedStrictness),
            30 => Some(Self::UnknownStrictEventOpenProtocol),
            31 => Some(Self::UnknownFlexibleEventOpenProtocol),
            32 => Some(Self::UnknownStrictEventAjarProtocol),
            33 => Some(Self::UnknownFlexibleEventAjarProtocol),
            34 => Some(Self::UnknownStrictEventClosedProtocol),
            35 => Some(Self::UnknownFlexibleEventClosedProtocol),
            36 => Some(Self::UnknownStrictServerInitiatedTwoWay),
            37 => Some(Self::UnknownFlexibleServerInitiatedTwoWay),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
        match prim {
            1 => Self::Setup,
            2 => Self::TwoWayNoPayload,
            42 => Self::TwoWayStructPayload,
            43 => Self::TwoWayTablePayload,
            44 => Self::TwoWayUnionPayload,
            45 => Self::TwoWayResultWithPayload,
            46 => Self::TwoWayResultWithError,
            52 => Self::TwoWayStructRequest,
            53 => Self::TwoWayTableRequest,
            54 => Self::TwoWayUnionRequest,
            48 => Self::OneWayNoRequest,
            49 => Self::OneWayStructRequest,
            50 => Self::OneWayTableRequest,
            51 => Self::OneWayUnionRequest,
            55 => Self::ReceiveEventNoPayload,
            56 => Self::ReceiveEventStructPayload,
            57 => Self::ReceiveEventTablePayload,
            58 => Self::ReceiveEventUnionPayload,
            3 => Self::GracefulFailureDuringCallAfterPeerClose,
            60 => Self::ReceiveEventBadMagicNumber,
            61 => Self::ReceiveEventUnexpectedTxid,
            62 => Self::ReceiveEventUnknownOrdinal,
            63 => Self::ReceiveResponseBadMagicNumber,
            64 => Self::ReceiveResponseUnexpectedTxid,
            65 => Self::ReceiveResponseWrongOrdinalKnown,
            67 => Self::ReceiveResponseWrongOrdinalUnknown,
            40 => Self::V1TwoWayNoPayload,
            41 => Self::V1TwoWayStructPayload,
            59 => Self::OneWayCallDoNotReportPeerClosed,
            4 => Self::OneWayStrictSend,
            5 => Self::OneWayFlexibleSend,
            6 => Self::TwoWayStrictSend,
            7 => Self::TwoWayStrictSendMismatchedStrictness,
            38 => Self::TwoWayStrictSendNonEmptyPayload,
            8 => Self::TwoWayStrictErrorSyntaxSendSuccessResponse,
            9 => Self::TwoWayStrictErrorSyntaxSendErrorResponse,
            10 => Self::TwoWayStrictErrorSyntaxSendUnknownMethodResponse,
            11 => Self::TwoWayStrictErrorSyntaxSendMismatchedStrictnessUnknownMethodResponse,
            39 => Self::TwoWayStrictErrorSyntaxSendNonEmptyPayload,
            12 => Self::TwoWayFlexibleSendSuccessResponse,
            13 => Self::TwoWayFlexibleSendErrorResponse,
            14 => Self::TwoWayFlexibleSendUnknownMethodResponse,
            15 => Self::TwoWayFlexibleSendMismatchedStrictnessUnknownMethodResponse,
            16 => Self::TwoWayFlexibleSendOtherFrameworkErrResponse,
            17 => Self::TwoWayFlexibleSendNonEmptyPayloadSuccessResponse,
            18 => Self::TwoWayFlexibleSendNonEmptyPayloadUnknownMethodResponse,
            19 => Self::TwoWayFlexibleErrorSyntaxSendSuccessResponse,
            20 => Self::TwoWayFlexibleErrorSyntaxSendErrorResponse,
            21 => Self::TwoWayFlexibleErrorSyntaxSendUnknownMethodResponse,
            22 => Self::TwoWayFlexibleErrorSyntaxSendMismatchedStrictnessUnknownMethodResponse,
            23 => Self::TwoWayFlexibleErrorSyntaxSendOtherFrameworkErrResponse,
            24 => Self::TwoWayFlexibleErrorSyntaxSendNonEmptyPayloadSuccessResponse,
            25 => Self::TwoWayFlexibleErrorSyntaxSendNonEmptyPayloadUnknownMethodResponse,
            26 => Self::ReceiveStrictEvent,
            27 => Self::ReceiveStrictEventMismatchedStrictness,
            28 => Self::ReceiveFlexibleEvent,
            29 => Self::ReceiveFlexibleEventMismatchedStrictness,
            30 => Self::UnknownStrictEventOpenProtocol,
            31 => Self::UnknownFlexibleEventOpenProtocol,
            32 => Self::UnknownStrictEventAjarProtocol,
            33 => Self::UnknownFlexibleEventAjarProtocol,
            34 => Self::UnknownStrictEventClosedProtocol,
            35 => Self::UnknownFlexibleEventClosedProtocol,
            36 => Self::UnknownStrictServerInitiatedTwoWay,
            37 => Self::UnknownFlexibleServerInitiatedTwoWay,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

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

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        match self {
            Self::Setup => 1,
            Self::TwoWayNoPayload => 2,
            Self::TwoWayStructPayload => 42,
            Self::TwoWayTablePayload => 43,
            Self::TwoWayUnionPayload => 44,
            Self::TwoWayResultWithPayload => 45,
            Self::TwoWayResultWithError => 46,
            Self::TwoWayStructRequest => 52,
            Self::TwoWayTableRequest => 53,
            Self::TwoWayUnionRequest => 54,
            Self::OneWayNoRequest => 48,
            Self::OneWayStructRequest => 49,
            Self::OneWayTableRequest => 50,
            Self::OneWayUnionRequest => 51,
            Self::ReceiveEventNoPayload => 55,
            Self::ReceiveEventStructPayload => 56,
            Self::ReceiveEventTablePayload => 57,
            Self::ReceiveEventUnionPayload => 58,
            Self::GracefulFailureDuringCallAfterPeerClose => 3,
            Self::ReceiveEventBadMagicNumber => 60,
            Self::ReceiveEventUnexpectedTxid => 61,
            Self::ReceiveEventUnknownOrdinal => 62,
            Self::ReceiveResponseBadMagicNumber => 63,
            Self::ReceiveResponseUnexpectedTxid => 64,
            Self::ReceiveResponseWrongOrdinalKnown => 65,
            Self::ReceiveResponseWrongOrdinalUnknown => 67,
            Self::V1TwoWayNoPayload => 40,
            Self::V1TwoWayStructPayload => 41,
            Self::OneWayCallDoNotReportPeerClosed => 59,
            Self::OneWayStrictSend => 4,
            Self::OneWayFlexibleSend => 5,
            Self::TwoWayStrictSend => 6,
            Self::TwoWayStrictSendMismatchedStrictness => 7,
            Self::TwoWayStrictSendNonEmptyPayload => 38,
            Self::TwoWayStrictErrorSyntaxSendSuccessResponse => 8,
            Self::TwoWayStrictErrorSyntaxSendErrorResponse => 9,
            Self::TwoWayStrictErrorSyntaxSendUnknownMethodResponse => 10,
            Self::TwoWayStrictErrorSyntaxSendMismatchedStrictnessUnknownMethodResponse => 11,
            Self::TwoWayStrictErrorSyntaxSendNonEmptyPayload => 39,
            Self::TwoWayFlexibleSendSuccessResponse => 12,
            Self::TwoWayFlexibleSendErrorResponse => 13,
            Self::TwoWayFlexibleSendUnknownMethodResponse => 14,
            Self::TwoWayFlexibleSendMismatchedStrictnessUnknownMethodResponse => 15,
            Self::TwoWayFlexibleSendOtherFrameworkErrResponse => 16,
            Self::TwoWayFlexibleSendNonEmptyPayloadSuccessResponse => 17,
            Self::TwoWayFlexibleSendNonEmptyPayloadUnknownMethodResponse => 18,
            Self::TwoWayFlexibleErrorSyntaxSendSuccessResponse => 19,
            Self::TwoWayFlexibleErrorSyntaxSendErrorResponse => 20,
            Self::TwoWayFlexibleErrorSyntaxSendUnknownMethodResponse => 21,
            Self::TwoWayFlexibleErrorSyntaxSendMismatchedStrictnessUnknownMethodResponse => 22,
            Self::TwoWayFlexibleErrorSyntaxSendOtherFrameworkErrResponse => 23,
            Self::TwoWayFlexibleErrorSyntaxSendNonEmptyPayloadSuccessResponse => 24,
            Self::TwoWayFlexibleErrorSyntaxSendNonEmptyPayloadUnknownMethodResponse => 25,
            Self::ReceiveStrictEvent => 26,
            Self::ReceiveStrictEventMismatchedStrictness => 27,
            Self::ReceiveFlexibleEvent => 28,
            Self::ReceiveFlexibleEventMismatchedStrictness => 29,
            Self::UnknownStrictEventOpenProtocol => 30,
            Self::UnknownFlexibleEventOpenProtocol => 31,
            Self::UnknownStrictEventAjarProtocol => 32,
            Self::UnknownFlexibleEventAjarProtocol => 33,
            Self::UnknownStrictEventClosedProtocol => 34,
            Self::UnknownFlexibleEventClosedProtocol => 35,
            Self::UnknownStrictServerInitiatedTwoWay => 36,
            Self::UnknownFlexibleServerInitiatedTwoWay => 37,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

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

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

impl fidl::Persistable for Empty {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct NonEmptyPayload {
    pub some_field: i32,
}

impl fidl::Persistable for NonEmptyPayload {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct RunnerGetVersionResponse {
    pub version: u64,
}

impl fidl::Persistable for RunnerGetVersionResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerIsTestEnabledRequest {
    pub test: Test,
}

impl fidl::Persistable for RunnerIsTestEnabledRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct RunnerIsTestEnabledResponse {
    pub is_enabled: bool,
}

impl fidl::Persistable for RunnerIsTestEnabledResponse {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct UnknownEvent {
    pub ordinal: u64,
}

impl fidl::Persistable for UnknownEvent {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct BindingsProperties {
    pub io_style: Option<IoStyle>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for BindingsProperties {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct TablePayload {
    pub some_field: Option<i32>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for TablePayload {}

#[derive(Clone, Debug)]
pub enum AjarTargetEventReport {
    FidlError(FidlErrorKind),
    UnknownEvent(UnknownEvent),
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u64,
    },
}

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

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

impl AjarTargetEventReport {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::FidlError(_) => 1,
            Self::UnknownEvent(_) => 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::Persistable for AjarTargetEventReport {}

#[derive(Clone, Debug)]
pub enum ClosedTargetEventReport {
    FidlError(FidlErrorKind),
    OnEventNoPayload(Empty),
    OnEventStructPayload(NonEmptyPayload),
    OnEventTablePayload(TablePayload),
    OnEventUnionPayload(UnionPayload),
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u64,
    },
}

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

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

impl ClosedTargetEventReport {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::FidlError(_) => 1,
            Self::OnEventNoPayload(_) => 2,
            Self::OnEventStructPayload(_) => 3,
            Self::OnEventTablePayload(_) => 4,
            Self::OnEventUnionPayload(_) => 5,
            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::Persistable for ClosedTargetEventReport {}

#[derive(Clone, Debug)]
pub enum EmptyResultClassification {
    Success(Empty),
    FidlError(FidlErrorKind),
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u64,
    },
}

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

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

impl EmptyResultClassification {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Success(_) => 1,
            Self::FidlError(_) => 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::Persistable for EmptyResultClassification {}

#[derive(Clone, Debug)]
pub enum EmptyResultWithErrorClassification {
    Success(Empty),
    ApplicationError(i32),
    FidlError(FidlErrorKind),
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u64,
    },
}

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

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

impl EmptyResultWithErrorClassification {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Success(_) => 1,
            Self::ApplicationError(_) => 2,
            Self::FidlError(_) => 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::Persistable for EmptyResultWithErrorClassification {}

#[derive(Clone, Debug)]
pub enum NonEmptyResultClassification {
    Success(NonEmptyPayload),
    FidlError(FidlErrorKind),
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u64,
    },
}

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

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

impl NonEmptyResultClassification {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Success(_) => 1,
            Self::FidlError(_) => 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::Persistable for NonEmptyResultClassification {}

#[derive(Clone, Debug)]
pub enum NonEmptyResultWithErrorClassification {
    Success(NonEmptyPayload),
    ApplicationError(i32),
    FidlError(FidlErrorKind),
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u64,
    },
}

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

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

impl NonEmptyResultWithErrorClassification {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Success(_) => 1,
            Self::ApplicationError(_) => 2,
            Self::FidlError(_) => 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::Persistable for NonEmptyResultWithErrorClassification {}

#[derive(Clone, Debug)]
pub enum OpenTargetEventReport {
    FidlError(FidlErrorKind),
    UnknownEvent(UnknownEvent),
    StrictEvent(Empty),
    FlexibleEvent(Empty),
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u64,
    },
}

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

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

impl OpenTargetEventReport {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::FidlError(_) => 1,
            Self::UnknownEvent(_) => 2,
            Self::StrictEvent(_) => 3,
            Self::FlexibleEvent(_) => 4,
            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::Persistable for OpenTargetEventReport {}

#[derive(Clone, Debug)]
pub enum TableResultClassification {
    Success(TablePayload),
    FidlError(FidlErrorKind),
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u64,
    },
}

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

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

impl TableResultClassification {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Success(_) => 1,
            Self::FidlError(_) => 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::Persistable for TableResultClassification {}

#[derive(Clone, Debug)]
pub enum UnionPayload {
    SomeVariant(i32),
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u64,
    },
}

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

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

impl UnionPayload {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::SomeVariant(_) => 1,
            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::Persistable for UnionPayload {}

#[derive(Clone, Debug)]
pub enum UnionResultClassification {
    Success(UnionPayload),
    FidlError(FidlErrorKind),
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u64,
    },
}

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

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

impl UnionResultClassification {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Success(_) => 1,
            Self::FidlError(_) => 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::Persistable for UnionResultClassification {}

mod internal {
    use super::*;
    unsafe impl fidl::encoding::TypeMarker for FidlErrorKind {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for FidlErrorKind {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for FidlErrorKind {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FidlErrorKind {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::OtherError
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for IoStyle {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for IoStyle {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for IoStyle {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IoStyle {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Sync
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for Test {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for Test {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Test {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Test {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for Empty {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Empty, D> for &Empty {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Empty>(offset);
            encoder.write_num(0u8, offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Empty {
        #[inline(always)]
        fn new_empty() -> Self {
            Self
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            match decoder.read_num::<u8>(offset) {
                0 => Ok(()),
                _ => Err(fidl::Error::Invalid),
            }
        }
    }

    impl fidl::encoding::ValueTypeMarker for NonEmptyPayload {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NonEmptyPayload {
        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
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NonEmptyPayload, D>
        for &NonEmptyPayload
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NonEmptyPayload>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut NonEmptyPayload)
                    .write_unaligned((self as *const NonEmptyPayload).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<i32, D>>
        fidl::encoding::Encode<NonEmptyPayload, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NonEmptyPayload>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NonEmptyPayload {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { some_field: fidl::new_empty!(i32, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 4);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for RunnerGetVersionResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for RunnerGetVersionResponse {
        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
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<RunnerGetVersionResponse, D> for &RunnerGetVersionResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RunnerGetVersionResponse>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut RunnerGetVersionResponse)
                    .write_unaligned((self as *const RunnerGetVersionResponse).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
        fidl::encoding::Encode<RunnerGetVersionResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RunnerGetVersionResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for RunnerGetVersionResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { version: fidl::new_empty!(u64, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for RunnerIsTestEnabledRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for RunnerIsTestEnabledRequest {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<RunnerIsTestEnabledRequest, D> for &RunnerIsTestEnabledRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RunnerIsTestEnabledRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerIsTestEnabledRequest, D>::encode(
                (<Test as fidl::encoding::ValueTypeMarker>::borrow(&self.test),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Test, D>>
        fidl::encoding::Encode<RunnerIsTestEnabledRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RunnerIsTestEnabledRequest>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for RunnerIsTestEnabledRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { test: fidl::new_empty!(Test, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for RunnerIsTestEnabledResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

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

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

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

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<RunnerIsTestEnabledResponse, D> for &RunnerIsTestEnabledResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RunnerIsTestEnabledResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<RunnerIsTestEnabledResponse, D>::encode(
                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.is_enabled),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
        fidl::encoding::Encode<RunnerIsTestEnabledResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RunnerIsTestEnabledResponse>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for RunnerIsTestEnabledResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { is_enabled: fidl::new_empty!(bool, D) }
        }

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

    impl fidl::encoding::ValueTypeMarker for UnknownEvent {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for UnknownEvent {
        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
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UnknownEvent, D>
        for &UnknownEvent
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UnknownEvent>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut UnknownEvent)
                    .write_unaligned((self as *const UnknownEvent).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
        fidl::encoding::Encode<UnknownEvent, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UnknownEvent>(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<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UnknownEvent {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { ordinal: fidl::new_empty!(u64, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
            }
            Ok(())
        }
    }

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

    impl fidl::encoding::ValueTypeMarker for BindingsProperties {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for BindingsProperties {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BindingsProperties, D>
        for &BindingsProperties
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<BindingsProperties>(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::<IoStyle, D>(
                self.io_style.as_ref().map(<IoStyle as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 =
                    <IoStyle 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.io_style.get_or_insert_with(|| fidl::new_empty!(IoStyle, D));
                fidl::decode!(IoStyle, D, 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 TablePayload {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.some_field {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for TablePayload {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TablePayload {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TablePayload, D>
        for &TablePayload
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TablePayload>(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::<i32, D>(
                self.some_field.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 =
                    <i32 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.some_field.get_or_insert_with(|| fidl::new_empty!(i32, D));
                fidl::decode!(i32, D, 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::ValueTypeMarker for AjarTargetEventReport {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for AjarTargetEventReport {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AjarTargetEventReport, D>
        for &AjarTargetEventReport
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AjarTargetEventReport>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                AjarTargetEventReport::FidlError(ref val) => {
                    fidl::encoding::encode_in_envelope::<FidlErrorKind, D>(
                        <FidlErrorKind as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                AjarTargetEventReport::UnknownEvent(ref val) => {
                    fidl::encoding::encode_in_envelope::<UnknownEvent, D>(
                        <UnknownEvent as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                AjarTargetEventReport::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
            }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AjarTargetEventReport {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 => <FidlErrorKind as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                2 => <UnknownEvent 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 AjarTargetEventReport::FidlError(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self =
                            AjarTargetEventReport::FidlError(fidl::new_empty!(FidlErrorKind, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let AjarTargetEventReport::FidlError(ref mut val) = self {
                        fidl::decode!(FidlErrorKind, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let AjarTargetEventReport::UnknownEvent(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self =
                            AjarTargetEventReport::UnknownEvent(fidl::new_empty!(UnknownEvent, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let AjarTargetEventReport::UnknownEvent(ref mut val) = self {
                        fidl::decode!(UnknownEvent, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = AjarTargetEventReport::__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::ValueTypeMarker for ClosedTargetEventReport {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ClosedTargetEventReport {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ClosedTargetEventReport, D> for &ClosedTargetEventReport
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ClosedTargetEventReport>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                ClosedTargetEventReport::FidlError(ref val) => {
                    fidl::encoding::encode_in_envelope::<FidlErrorKind, D>(
                        <FidlErrorKind as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                ClosedTargetEventReport::OnEventNoPayload(ref val) => {
                    fidl::encoding::encode_in_envelope::<Empty, D>(
                        <Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                ClosedTargetEventReport::OnEventStructPayload(ref val) => {
                    fidl::encoding::encode_in_envelope::<NonEmptyPayload, D>(
                        <NonEmptyPayload as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                ClosedTargetEventReport::OnEventTablePayload(ref val) => {
                    fidl::encoding::encode_in_envelope::<TablePayload, D>(
                        <TablePayload as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                ClosedTargetEventReport::OnEventUnionPayload(ref val) => {
                    fidl::encoding::encode_in_envelope::<UnionPayload, D>(
                        <UnionPayload as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                ClosedTargetEventReport::__SourceBreaking { .. } => {
                    Err(fidl::Error::UnknownUnionTag)
                }
            }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ClosedTargetEventReport
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 => <FidlErrorKind as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                2 => <Empty as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                3 => <NonEmptyPayload as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                4 => <TablePayload as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                5 => <UnionPayload 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 ClosedTargetEventReport::FidlError(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self =
                            ClosedTargetEventReport::FidlError(fidl::new_empty!(FidlErrorKind, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ClosedTargetEventReport::FidlError(ref mut val) = self {
                        fidl::decode!(FidlErrorKind, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ClosedTargetEventReport::OnEventNoPayload(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self =
                            ClosedTargetEventReport::OnEventNoPayload(fidl::new_empty!(Empty, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ClosedTargetEventReport::OnEventNoPayload(ref mut val) = self {
                        fidl::decode!(Empty, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ClosedTargetEventReport::OnEventStructPayload(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ClosedTargetEventReport::OnEventStructPayload(fidl::new_empty!(
                            NonEmptyPayload,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ClosedTargetEventReport::OnEventStructPayload(ref mut val) = self {
                        fidl::decode!(NonEmptyPayload, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                4 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ClosedTargetEventReport::OnEventTablePayload(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ClosedTargetEventReport::OnEventTablePayload(fidl::new_empty!(
                            TablePayload,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ClosedTargetEventReport::OnEventTablePayload(ref mut val) = self {
                        fidl::decode!(TablePayload, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                5 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ClosedTargetEventReport::OnEventUnionPayload(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ClosedTargetEventReport::OnEventUnionPayload(fidl::new_empty!(
                            UnionPayload,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ClosedTargetEventReport::OnEventUnionPayload(ref mut val) = self {
                        fidl::decode!(UnionPayload, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = ClosedTargetEventReport::__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::ValueTypeMarker for EmptyResultClassification {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for EmptyResultClassification {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<EmptyResultClassification, D> for &EmptyResultClassification
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EmptyResultClassification>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                EmptyResultClassification::Success(ref val) => {
                    fidl::encoding::encode_in_envelope::<Empty, D>(
                        <Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                EmptyResultClassification::FidlError(ref val) => {
                    fidl::encoding::encode_in_envelope::<FidlErrorKind, D>(
                        <FidlErrorKind as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                EmptyResultClassification::__SourceBreaking { .. } => {
                    Err(fidl::Error::UnknownUnionTag)
                }
            }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for EmptyResultClassification
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 => <Empty as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                3 => <FidlErrorKind 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 EmptyResultClassification::Success(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EmptyResultClassification::Success(fidl::new_empty!(Empty, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EmptyResultClassification::Success(ref mut val) = self {
                        fidl::decode!(Empty, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let EmptyResultClassification::FidlError(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EmptyResultClassification::FidlError(fidl::new_empty!(
                            FidlErrorKind,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EmptyResultClassification::FidlError(ref mut val) = self {
                        fidl::decode!(FidlErrorKind, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self =
                        EmptyResultClassification::__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::ValueTypeMarker for EmptyResultWithErrorClassification {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for EmptyResultWithErrorClassification {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<EmptyResultWithErrorClassification, D>
        for &EmptyResultWithErrorClassification
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EmptyResultWithErrorClassification>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                EmptyResultWithErrorClassification::Success(ref val) => {
                    fidl::encoding::encode_in_envelope::<Empty, D>(
                        <Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                EmptyResultWithErrorClassification::ApplicationError(ref val) => {
                    fidl::encoding::encode_in_envelope::<i32, D>(
                        <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                EmptyResultWithErrorClassification::FidlError(ref val) => {
                    fidl::encoding::encode_in_envelope::<FidlErrorKind, D>(
                        <FidlErrorKind as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                EmptyResultWithErrorClassification::__SourceBreaking { .. } => {
                    Err(fidl::Error::UnknownUnionTag)
                }
            }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for EmptyResultWithErrorClassification
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 => <Empty as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                2 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                3 => <FidlErrorKind 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 EmptyResultWithErrorClassification::Success(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self =
                            EmptyResultWithErrorClassification::Success(fidl::new_empty!(Empty, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EmptyResultWithErrorClassification::Success(ref mut val) = self {
                        fidl::decode!(Empty, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let EmptyResultWithErrorClassification::ApplicationError(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EmptyResultWithErrorClassification::ApplicationError(
                            fidl::new_empty!(i32, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EmptyResultWithErrorClassification::ApplicationError(ref mut val) = self
                    {
                        fidl::decode!(i32, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let EmptyResultWithErrorClassification::FidlError(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EmptyResultWithErrorClassification::FidlError(fidl::new_empty!(
                            FidlErrorKind,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EmptyResultWithErrorClassification::FidlError(ref mut val) = self {
                        fidl::decode!(FidlErrorKind, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = EmptyResultWithErrorClassification::__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::ValueTypeMarker for NonEmptyResultClassification {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NonEmptyResultClassification {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<NonEmptyResultClassification, D> for &NonEmptyResultClassification
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NonEmptyResultClassification>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                NonEmptyResultClassification::Success(ref val) => {
                    fidl::encoding::encode_in_envelope::<NonEmptyPayload, D>(
                        <NonEmptyPayload as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                NonEmptyResultClassification::FidlError(ref val) => {
                    fidl::encoding::encode_in_envelope::<FidlErrorKind, D>(
                        <FidlErrorKind as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                NonEmptyResultClassification::__SourceBreaking { .. } => {
                    Err(fidl::Error::UnknownUnionTag)
                }
            }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for NonEmptyResultClassification
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 => <NonEmptyPayload as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                3 => <FidlErrorKind 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 NonEmptyResultClassification::Success(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = NonEmptyResultClassification::Success(fidl::new_empty!(
                            NonEmptyPayload,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let NonEmptyResultClassification::Success(ref mut val) = self {
                        fidl::decode!(NonEmptyPayload, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let NonEmptyResultClassification::FidlError(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = NonEmptyResultClassification::FidlError(fidl::new_empty!(
                            FidlErrorKind,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let NonEmptyResultClassification::FidlError(ref mut val) = self {
                        fidl::decode!(FidlErrorKind, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self =
                        NonEmptyResultClassification::__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::ValueTypeMarker for NonEmptyResultWithErrorClassification {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NonEmptyResultWithErrorClassification {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<NonEmptyResultWithErrorClassification, D>
        for &NonEmptyResultWithErrorClassification
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NonEmptyResultWithErrorClassification>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                NonEmptyResultWithErrorClassification::Success(ref val) => {
                    fidl::encoding::encode_in_envelope::<NonEmptyPayload, D>(
                        <NonEmptyPayload as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                NonEmptyResultWithErrorClassification::ApplicationError(ref val) => {
                    fidl::encoding::encode_in_envelope::<i32, D>(
                        <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                NonEmptyResultWithErrorClassification::FidlError(ref val) => {
                    fidl::encoding::encode_in_envelope::<FidlErrorKind, D>(
                        <FidlErrorKind as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                NonEmptyResultWithErrorClassification::__SourceBreaking { .. } => {
                    Err(fidl::Error::UnknownUnionTag)
                }
            }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for NonEmptyResultWithErrorClassification
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 => <NonEmptyPayload as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                2 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                3 => <FidlErrorKind 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 NonEmptyResultWithErrorClassification::Success(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = NonEmptyResultWithErrorClassification::Success(fidl::new_empty!(
                            NonEmptyPayload,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let NonEmptyResultWithErrorClassification::Success(ref mut val) = self {
                        fidl::decode!(NonEmptyPayload, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let NonEmptyResultWithErrorClassification::ApplicationError(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = NonEmptyResultWithErrorClassification::ApplicationError(
                            fidl::new_empty!(i32, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let NonEmptyResultWithErrorClassification::ApplicationError(ref mut val) =
                        self
                    {
                        fidl::decode!(i32, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let NonEmptyResultWithErrorClassification::FidlError(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = NonEmptyResultWithErrorClassification::FidlError(fidl::new_empty!(
                            FidlErrorKind,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let NonEmptyResultWithErrorClassification::FidlError(ref mut val) = self {
                        fidl::decode!(FidlErrorKind, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = NonEmptyResultWithErrorClassification::__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::ValueTypeMarker for OpenTargetEventReport {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for OpenTargetEventReport {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OpenTargetEventReport, D>
        for &OpenTargetEventReport
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<OpenTargetEventReport>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                OpenTargetEventReport::FidlError(ref val) => {
                    fidl::encoding::encode_in_envelope::<FidlErrorKind, D>(
                        <FidlErrorKind as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                OpenTargetEventReport::UnknownEvent(ref val) => {
                    fidl::encoding::encode_in_envelope::<UnknownEvent, D>(
                        <UnknownEvent as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                OpenTargetEventReport::StrictEvent(ref val) => {
                    fidl::encoding::encode_in_envelope::<Empty, D>(
                        <Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                OpenTargetEventReport::FlexibleEvent(ref val) => {
                    fidl::encoding::encode_in_envelope::<Empty, D>(
                        <Empty as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                OpenTargetEventReport::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
            }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OpenTargetEventReport {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 => <FidlErrorKind as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                2 => <UnknownEvent as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                3 => <Empty as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                4 => <Empty 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 OpenTargetEventReport::FidlError(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self =
                            OpenTargetEventReport::FidlError(fidl::new_empty!(FidlErrorKind, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let OpenTargetEventReport::FidlError(ref mut val) = self {
                        fidl::decode!(FidlErrorKind, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let OpenTargetEventReport::UnknownEvent(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self =
                            OpenTargetEventReport::UnknownEvent(fidl::new_empty!(UnknownEvent, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let OpenTargetEventReport::UnknownEvent(ref mut val) = self {
                        fidl::decode!(UnknownEvent, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let OpenTargetEventReport::StrictEvent(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = OpenTargetEventReport::StrictEvent(fidl::new_empty!(Empty, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let OpenTargetEventReport::StrictEvent(ref mut val) = self {
                        fidl::decode!(Empty, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                4 => {
                    #[allow(irrefutable_let_patterns)]
                    if let OpenTargetEventReport::FlexibleEvent(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = OpenTargetEventReport::FlexibleEvent(fidl::new_empty!(Empty, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let OpenTargetEventReport::FlexibleEvent(ref mut val) = self {
                        fidl::decode!(Empty, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = OpenTargetEventReport::__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::ValueTypeMarker for TableResultClassification {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for TableResultClassification {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<TableResultClassification, D> for &TableResultClassification
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<TableResultClassification>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                TableResultClassification::Success(ref val) => {
                    fidl::encoding::encode_in_envelope::<TablePayload, D>(
                        <TablePayload as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                TableResultClassification::FidlError(ref val) => {
                    fidl::encoding::encode_in_envelope::<FidlErrorKind, D>(
                        <FidlErrorKind as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                TableResultClassification::__SourceBreaking { .. } => {
                    Err(fidl::Error::UnknownUnionTag)
                }
            }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for TableResultClassification
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 => <TablePayload as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                3 => <FidlErrorKind 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 TableResultClassification::Success(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self =
                            TableResultClassification::Success(fidl::new_empty!(TablePayload, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let TableResultClassification::Success(ref mut val) = self {
                        fidl::decode!(TablePayload, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let TableResultClassification::FidlError(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = TableResultClassification::FidlError(fidl::new_empty!(
                            FidlErrorKind,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let TableResultClassification::FidlError(ref mut val) = self {
                        fidl::decode!(FidlErrorKind, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self =
                        TableResultClassification::__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::ValueTypeMarker for UnionPayload {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for UnionPayload {
        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<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UnionPayload, D>
        for &UnionPayload
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UnionPayload>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                UnionPayload::SomeVariant(ref val) => fidl::encoding::encode_in_envelope::<i32, D>(
                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                UnionPayload::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
            }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UnionPayload {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 => <i32 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 UnionPayload::SomeVariant(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = UnionPayload::SomeVariant(fidl::new_empty!(i32, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let UnionPayload::SomeVariant(ref mut val) = self {
                        fidl::decode!(i32, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = UnionPayload::__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::ValueTypeMarker for UnionResultClassification {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for UnionResultClassification {
        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<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<UnionResultClassification, D> for &UnionResultClassification
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UnionResultClassification>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                UnionResultClassification::Success(ref val) => {
                    fidl::encoding::encode_in_envelope::<UnionPayload, D>(
                        <UnionPayload as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                UnionResultClassification::FidlError(ref val) => {
                    fidl::encoding::encode_in_envelope::<FidlErrorKind, D>(
                        <FidlErrorKind as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                UnionResultClassification::__SourceBreaking { .. } => {
                    Err(fidl::Error::UnknownUnionTag)
                }
            }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for UnionResultClassification
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            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 => <UnionPayload as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                3 => <FidlErrorKind 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 UnionResultClassification::Success(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self =
                            UnionResultClassification::Success(fidl::new_empty!(UnionPayload, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let UnionResultClassification::Success(ref mut val) = self {
                        fidl::decode!(UnionPayload, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let UnionResultClassification::FidlError(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = UnionResultClassification::FidlError(fidl::new_empty!(
                            FidlErrorKind,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let UnionResultClassification::FidlError(ref mut val) = self {
                        fidl::decode!(FidlErrorKind, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self =
                        UnionResultClassification::__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(())
        }
    }
}