fidl_next_fuchsia_hardware_spmi/

fidl_next_fuchsia_hardware_spmi.rs

// DO NOT EDIT: This file is machine-generated by fidlgen
#![warn(clippy::all)]
#![allow(unused_parens, unused_variables, unused_mut, unused_imports, unreachable_code)]

pub mod natural {

    pub use fidl_next_common_fuchsia_hardware_spmi::natural::*;

    #[derive(Debug, PartialEq)]
    pub struct DebugConnectTargetRequest {
        pub target_id: u8,

        pub server: ::fidl_next::ServerEnd<crate::Device, ::fidl_next::fuchsia::zx::Channel>,
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::DebugConnectTargetRequest, ___E>
        for DebugConnectTargetRequest
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::fuchsia::HandleEncoder,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::DebugConnectTargetRequest>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::DebugConnectTargetRequest {
                    target_id,
                    server,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.target_id, encoder_, target_id, ())?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(target_id.as_mut_ptr()) };

            ::fidl_next::Encode::encode(self.server, encoder_, server, ())?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(server.as_mut_ptr()) };

            Ok(())
        }
    }

    unsafe impl<___E>
        ::fidl_next::EncodeOption<
            ::fidl_next::wire::Box<'static, crate::wire::DebugConnectTargetRequest>,
            ___E,
        > for DebugConnectTargetRequest
    where
        ___E: ::fidl_next::Encoder + ?Sized,
        DebugConnectTargetRequest:
            ::fidl_next::Encode<crate::wire::DebugConnectTargetRequest, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<
                ::fidl_next::wire::Box<'static, crate::wire::DebugConnectTargetRequest>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            if let Some(inner) = this {
                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
                ::fidl_next::wire::Box::encode_present(out);
            } else {
                ::fidl_next::wire::Box::encode_absent(out);
            }

            Ok(())
        }
    }

    impl ::fidl_next::FromWire<crate::wire::DebugConnectTargetRequest> for DebugConnectTargetRequest {
        #[inline]
        fn from_wire(wire: crate::wire::DebugConnectTargetRequest) -> Self {
            Self {
                target_id: ::fidl_next::FromWire::from_wire(wire.target_id),

                server: ::fidl_next::FromWire::from_wire(wire.server),
            }
        }
    }

    #[derive(Debug, PartialEq)]
    pub struct DeviceWatchControllerWriteCommandsRequest {
        pub address: u8,

        pub size: u16,

        pub setup_wake_lease: ::core::option::Option<::fidl_next::fuchsia::zx::EventPair>,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<crate::wire::DeviceWatchControllerWriteCommandsRequest, ___E>
        for DeviceWatchControllerWriteCommandsRequest
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::fuchsia::HandleEncoder,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::DeviceWatchControllerWriteCommandsRequest,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::DeviceWatchControllerWriteCommandsRequest {
                    address,
                    size,
                    setup_wake_lease,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.address, encoder_, address, ())?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(address.as_mut_ptr()) };

            ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(size.as_mut_ptr()) };

            ::fidl_next::Encode::encode(self.setup_wake_lease, encoder_, setup_wake_lease, ())?;

            let mut _field =
                unsafe { ::fidl_next::Slot::new_unchecked(setup_wake_lease.as_mut_ptr()) };

            Ok(())
        }
    }

    unsafe impl<___E>
        ::fidl_next::EncodeOption<
            ::fidl_next::wire::Box<'static, crate::wire::DeviceWatchControllerWriteCommandsRequest>,
            ___E,
        > for DeviceWatchControllerWriteCommandsRequest
    where
        ___E: ::fidl_next::Encoder + ?Sized,
        DeviceWatchControllerWriteCommandsRequest:
            ::fidl_next::Encode<crate::wire::DeviceWatchControllerWriteCommandsRequest, ___E>,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<
                ::fidl_next::wire::Box<
                    'static,
                    crate::wire::DeviceWatchControllerWriteCommandsRequest,
                >,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            if let Some(inner) = this {
                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
                ::fidl_next::wire::Box::encode_present(out);
            } else {
                ::fidl_next::wire::Box::encode_absent(out);
            }

            Ok(())
        }
    }

    impl ::fidl_next::FromWire<crate::wire::DeviceWatchControllerWriteCommandsRequest>
        for DeviceWatchControllerWriteCommandsRequest
    {
        #[inline]
        fn from_wire(wire: crate::wire::DeviceWatchControllerWriteCommandsRequest) -> Self {
            Self {
                address: ::fidl_next::FromWire::from_wire(wire.address),

                size: ::fidl_next::FromWire::from_wire(wire.size),

                setup_wake_lease: ::fidl_next::FromWire::from_wire(wire.setup_wake_lease),
            }
        }
    }

    #[derive(Debug, PartialEq)]
    pub struct DeviceWatchControllerWriteCommandsResponse {
        pub writes: ::std::vec::Vec<crate::natural::Register8>,

        pub wake_lease: ::core::option::Option<::fidl_next::fuchsia::zx::EventPair>,
    }

    unsafe impl<___E>
        ::fidl_next::Encode<crate::wire::DeviceWatchControllerWriteCommandsResponse<'static>, ___E>
        for DeviceWatchControllerWriteCommandsResponse
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
        ___E: ::fidl_next::fuchsia::HandleEncoder,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::DeviceWatchControllerWriteCommandsResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::DeviceWatchControllerWriteCommandsResponse {
                    writes,
                    wake_lease,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.writes, encoder_, writes, (256, ()))?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(writes.as_mut_ptr()) };
            ::fidl_next::Constrained::validate(_field, (256, ()))?;

            ::fidl_next::Encode::encode(self.wake_lease, encoder_, wake_lease, ())?;

            let mut _field = unsafe { ::fidl_next::Slot::new_unchecked(wake_lease.as_mut_ptr()) };

            Ok(())
        }
    }

    unsafe impl<___E>
        ::fidl_next::EncodeOption<
            ::fidl_next::wire::Box<
                'static,
                crate::wire::DeviceWatchControllerWriteCommandsResponse<'static>,
            >,
            ___E,
        > for DeviceWatchControllerWriteCommandsResponse
    where
        ___E: ::fidl_next::Encoder + ?Sized,
        DeviceWatchControllerWriteCommandsResponse: ::fidl_next::Encode<
                crate::wire::DeviceWatchControllerWriteCommandsResponse<'static>,
                ___E,
            >,
    {
        #[inline]
        fn encode_option(
            this: ::core::option::Option<Self>,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<
                ::fidl_next::wire::Box<
                    'static,
                    crate::wire::DeviceWatchControllerWriteCommandsResponse<'static>,
                >,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            if let Some(inner) = this {
                ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
                ::fidl_next::wire::Box::encode_present(out);
            } else {
                ::fidl_next::wire::Box::encode_absent(out);
            }

            Ok(())
        }
    }

    impl<'de> ::fidl_next::FromWire<crate::wire::DeviceWatchControllerWriteCommandsResponse<'de>>
        for DeviceWatchControllerWriteCommandsResponse
    {
        #[inline]
        fn from_wire(wire: crate::wire::DeviceWatchControllerWriteCommandsResponse<'de>) -> Self {
            Self {
                writes: ::fidl_next::FromWire::from_wire(wire.writes),

                wake_lease: ::fidl_next::FromWire::from_wire(wire.wake_lease),
            }
        }
    }
}

pub mod wire {

    pub use fidl_next_common_fuchsia_hardware_spmi::wire::*;

    /// The wire type corresponding to [`DebugConnectTargetRequest`].
    #[derive(Debug)]
    #[repr(C)]
    pub struct DebugConnectTargetRequest {
        pub target_id: u8,

        pub server: ::fidl_next::ServerEnd<crate::Device, ::fidl_next::wire::fuchsia::Channel>,
    }

    static_assertions::const_assert_eq!(std::mem::size_of::<DebugConnectTargetRequest>(), 8);
    static_assertions::const_assert_eq!(std::mem::align_of::<DebugConnectTargetRequest>(), 4);

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(DebugConnectTargetRequest, target_id),
        0
    );

    static_assertions::const_assert_eq!(std::mem::offset_of!(DebugConnectTargetRequest, server), 4);

    impl ::fidl_next::Constrained for DebugConnectTargetRequest {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for DebugConnectTargetRequest {
        type Narrowed<'de> = DebugConnectTargetRequest;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {
                    target_id,
                    server,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(target_id);

            ::fidl_next::Wire::zero_padding(server);

            unsafe {
                out_.as_mut_ptr().cast::<u8>().add(1).write_bytes(0, 3);
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for DebugConnectTargetRequest
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::fuchsia::HandleDecoder,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            if slot_.as_bytes()[1..4] != [0u8; 3] {
                return Err(::fidl_next::DecodeError::InvalidPadding);
            }

            ::fidl_next::munge! {
                let Self {
                    mut target_id,
                    mut server,

                } = slot_;
            }

            let _field = target_id.as_mut();

            ::fidl_next::Decode::decode(target_id.as_mut(), decoder_, ())?;

            let _field = server.as_mut();

            ::fidl_next::Decode::decode(server.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for DebugConnectTargetRequest {
        type Natural = crate::natural::DebugConnectTargetRequest;
    }

    /// The wire type corresponding to [`DeviceWatchControllerWriteCommandsRequest`].
    #[derive(Debug)]
    #[repr(C)]
    pub struct DeviceWatchControllerWriteCommandsRequest {
        pub address: u8,

        pub size: ::fidl_next::wire::Uint16,

        pub setup_wake_lease: ::fidl_next::wire::fuchsia::OptionalEventPair,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<DeviceWatchControllerWriteCommandsRequest>(),
        8
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<DeviceWatchControllerWriteCommandsRequest>(),
        4
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(DeviceWatchControllerWriteCommandsRequest, address),
        0
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(DeviceWatchControllerWriteCommandsRequest, size),
        2
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(DeviceWatchControllerWriteCommandsRequest, setup_wake_lease),
        4
    );

    impl ::fidl_next::Constrained for DeviceWatchControllerWriteCommandsRequest {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for DeviceWatchControllerWriteCommandsRequest {
        type Narrowed<'de> = DeviceWatchControllerWriteCommandsRequest;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {
                    address,
                    size,
                    setup_wake_lease,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(address);

            ::fidl_next::Wire::zero_padding(size);

            ::fidl_next::Wire::zero_padding(setup_wake_lease);

            unsafe {
                out_.as_mut_ptr().cast::<u8>().add(1).write_bytes(0, 1);
            }
        }
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for DeviceWatchControllerWriteCommandsRequest
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::fuchsia::HandleDecoder,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            if slot_.as_bytes()[1..2] != [0u8; 1] {
                return Err(::fidl_next::DecodeError::InvalidPadding);
            }

            ::fidl_next::munge! {
                let Self {
                    mut address,
                    mut size,
                    mut setup_wake_lease,

                } = slot_;
            }

            let _field = address.as_mut();

            ::fidl_next::Decode::decode(address.as_mut(), decoder_, ())?;

            let _field = size.as_mut();

            ::fidl_next::Decode::decode(size.as_mut(), decoder_, ())?;

            let _field = setup_wake_lease.as_mut();

            ::fidl_next::Decode::decode(setup_wake_lease.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl ::fidl_next::IntoNatural for DeviceWatchControllerWriteCommandsRequest {
        type Natural = crate::natural::DeviceWatchControllerWriteCommandsRequest;
    }

    /// The wire type corresponding to [`DeviceWatchControllerWriteCommandsResponse`].
    #[derive(Debug)]
    #[repr(C)]
    pub struct DeviceWatchControllerWriteCommandsResponse<'de> {
        pub writes: ::fidl_next::wire::Vector<'de, crate::wire::Register8>,

        pub wake_lease: ::fidl_next::wire::fuchsia::OptionalEventPair,
    }

    static_assertions::const_assert_eq!(
        std::mem::size_of::<DeviceWatchControllerWriteCommandsResponse<'_>>(),
        24
    );
    static_assertions::const_assert_eq!(
        std::mem::align_of::<DeviceWatchControllerWriteCommandsResponse<'_>>(),
        8
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(DeviceWatchControllerWriteCommandsResponse<'_>, writes),
        0
    );

    static_assertions::const_assert_eq!(
        std::mem::offset_of!(DeviceWatchControllerWriteCommandsResponse<'_>, wake_lease),
        16
    );

    impl ::fidl_next::Constrained for DeviceWatchControllerWriteCommandsResponse<'_> {
        type Constraint = ();

        fn validate(
            _: ::fidl_next::Slot<'_, Self>,
            _: Self::Constraint,
        ) -> Result<(), ::fidl_next::ValidationError> {
            Ok(())
        }
    }

    unsafe impl ::fidl_next::Wire for DeviceWatchControllerWriteCommandsResponse<'static> {
        type Narrowed<'de> = DeviceWatchControllerWriteCommandsResponse<'de>;

        #[inline]
        fn zero_padding(out_: &mut ::core::mem::MaybeUninit<Self>) {
            ::fidl_next::munge! {
                let Self {
                    writes,
                    wake_lease,

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(writes);

            ::fidl_next::Wire::zero_padding(wake_lease);

            unsafe {
                out_.as_mut_ptr().cast::<u8>().add(20).write_bytes(0, 4);
            }
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for DeviceWatchControllerWriteCommandsResponse<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
        ___D: ::fidl_next::fuchsia::HandleDecoder,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            if slot_.as_bytes()[20..24] != [0u8; 4] {
                return Err(::fidl_next::DecodeError::InvalidPadding);
            }

            ::fidl_next::munge! {
                let Self {
                    mut writes,
                    mut wake_lease,

                } = slot_;
            }

            let _field = writes.as_mut();
            ::fidl_next::Constrained::validate(_field, (256, ()))?;
            ::fidl_next::Decode::decode(writes.as_mut(), decoder_, (256, ()))?;

            let writes = unsafe { writes.deref_unchecked() };

            if writes.len() > 256 {
                return Err(::fidl_next::DecodeError::VectorTooLong {
                    size: writes.len() as u64,
                    limit: 256,
                });
            }

            let _field = wake_lease.as_mut();

            ::fidl_next::Decode::decode(wake_lease.as_mut(), decoder_, ())?;

            Ok(())
        }
    }

    impl<'de> ::fidl_next::IntoNatural for DeviceWatchControllerWriteCommandsResponse<'de> {
        type Natural = crate::natural::DeviceWatchControllerWriteCommandsResponse;
    }
}

pub mod wire_optional {

    pub use fidl_next_common_fuchsia_hardware_spmi::wire_optional::*;
}

pub mod generic {

    pub use fidl_next_common_fuchsia_hardware_spmi::generic::*;

    /// The generic type corresponding to [`DebugConnectTargetRequest`].
    pub struct DebugConnectTargetRequest<T0, T1> {
        pub target_id: T0,

        pub server: T1,
    }

    unsafe impl<___E, T0, T1> ::fidl_next::Encode<crate::wire::DebugConnectTargetRequest, ___E>
        for DebugConnectTargetRequest<T0, T1>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::fuchsia::HandleEncoder,
        T0: ::fidl_next::Encode<u8, ___E>,
        T1: ::fidl_next::Encode<
                ::fidl_next::ServerEnd<crate::Device, ::fidl_next::wire::fuchsia::Channel>,
                ___E,
            >,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<crate::wire::DebugConnectTargetRequest>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::DebugConnectTargetRequest {
                    target_id,
                    server,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.target_id, encoder_, target_id, ())?;

            ::fidl_next::Encode::encode(self.server, encoder_, server, ())?;

            Ok(())
        }
    }

    /// The generic type corresponding to [`DeviceWatchControllerWriteCommandsRequest`].
    pub struct DeviceWatchControllerWriteCommandsRequest<T0, T1, T2> {
        pub address: T0,

        pub size: T1,

        pub setup_wake_lease: T2,
    }

    unsafe impl<___E, T0, T1, T2>
        ::fidl_next::Encode<crate::wire::DeviceWatchControllerWriteCommandsRequest, ___E>
        for DeviceWatchControllerWriteCommandsRequest<T0, T1, T2>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::fuchsia::HandleEncoder,
        T0: ::fidl_next::Encode<u8, ___E>,
        T1: ::fidl_next::Encode<::fidl_next::wire::Uint16, ___E>,
        T2: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalEventPair, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::DeviceWatchControllerWriteCommandsRequest,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::DeviceWatchControllerWriteCommandsRequest {
                    address,
                    size,
                    setup_wake_lease,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.address, encoder_, address, ())?;

            ::fidl_next::Encode::encode(self.size, encoder_, size, ())?;

            ::fidl_next::Encode::encode(self.setup_wake_lease, encoder_, setup_wake_lease, ())?;

            Ok(())
        }
    }

    /// The generic type corresponding to [`DeviceWatchControllerWriteCommandsResponse`].
    pub struct DeviceWatchControllerWriteCommandsResponse<T0, T1> {
        pub writes: T0,

        pub wake_lease: T1,
    }

    unsafe impl<___E, T0, T1>
        ::fidl_next::Encode<crate::wire::DeviceWatchControllerWriteCommandsResponse<'static>, ___E>
        for DeviceWatchControllerWriteCommandsResponse<T0, T1>
    where
        ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
        ___E: ::fidl_next::Encoder,
        ___E: ::fidl_next::fuchsia::HandleEncoder,
        T0: ::fidl_next::Encode<::fidl_next::wire::Vector<'static, crate::wire::Register8>, ___E>,
        T1: ::fidl_next::Encode<::fidl_next::wire::fuchsia::OptionalEventPair, ___E>,
    {
        #[inline]
        fn encode(
            self,
            encoder_: &mut ___E,
            out_: &mut ::core::mem::MaybeUninit<
                crate::wire::DeviceWatchControllerWriteCommandsResponse<'static>,
            >,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge! {
                let crate::wire::DeviceWatchControllerWriteCommandsResponse {
                    writes,
                    wake_lease,

                } = out_;
            }

            ::fidl_next::Encode::encode(self.writes, encoder_, writes, (256, ()))?;

            ::fidl_next::Encode::encode(self.wake_lease, encoder_, wake_lease, ())?;

            Ok(())
        }
    }
}

pub use self::natural::*;

/// The type corresponding to the Debug protocol.
#[derive(PartialEq, Debug)]
pub struct Debug;

#[cfg(target_os = "fuchsia")]
impl ::fidl_next::HasTransport for Debug {
    type Transport = ::fidl_next::fuchsia::zx::Channel;
}

pub mod debug {
    pub mod prelude {
        pub use crate::{
            Debug, DebugClientHandler, DebugLocalClientHandler, DebugLocalServerHandler,
            DebugServerHandler, debug,
        };

        pub use crate::natural::DebugConnectTargetRequest;

        pub use crate::natural::DebugGetControllerPropertiesResponse;

        pub use crate::natural::DebugConnectTargetResponse;

        pub use crate::natural::DriverError;
    }

    pub struct ConnectTarget;

    impl ::fidl_next::Method for ConnectTarget {
        const ORDINAL: u64 = 799648158518250777;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::Debug;

        type Request = crate::wire::DebugConnectTargetRequest;
    }

    impl ::fidl_next::TwoWayMethod for ConnectTarget {
        type Response = ::fidl_next::wire::Result<
            'static,
            crate::wire::DebugConnectTargetResponse,
            crate::wire::DriverError,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for ConnectTarget {
        type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for ConnectTarget {
        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct GetControllerProperties;

    impl ::fidl_next::Method for GetControllerProperties {
        const ORDINAL: u64 = 4733781216537150751;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Strict;

        type Protocol = crate::Debug;

        type Request = ::fidl_next::wire::EmptyMessageBody;
    }

    impl ::fidl_next::TwoWayMethod for GetControllerProperties {
        type Response =
            ::fidl_next::wire::Strict<crate::wire::DebugGetControllerPropertiesResponse<'static>>;
    }

    impl<___R> ::fidl_next::Respond<___R> for GetControllerProperties {
        type Output = ::fidl_next::Strict<___R>;

        fn respond(response: ___R) -> Self::Output {
            ::fidl_next::Strict(response)
        }
    }

    mod ___detail {
        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Debug
        where
            ___T: ::fidl_next::Transport,
        {
            type Client = DebugClient<___T>;
            type Server = DebugServer<___T>;
        }

        /// The client for the `Debug` protocol.
        #[repr(transparent)]
        pub struct DebugClient<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            client: ::fidl_next::protocol::Client<___T>,
        }

        impl<___T> DebugClient<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            #[doc = " Connects to the target device with the given ID. Equivalent to connecting to `TargetService`\n via the corresponding driver node.\n\n Returns `INVALID_ARGS` if `target_id` is greater than or equal to `MAX_TARGETS`.\n May return an error if there is no such target on the bus; otherwise errors will be returned\n when attempting to access the client.\n"]
            pub fn connect_target(
                &self,

                target_id: impl ::fidl_next::Encode<u8, <___T as ::fidl_next::Transport>::SendBuffer>,

                server: impl ::fidl_next::Encode<
                    ::fidl_next::ServerEnd<crate::Device, ::fidl_next::wire::fuchsia::Channel>,
                    <___T as ::fidl_next::Transport>::SendBuffer,
                >,
            ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectTarget, ___T>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.connect_target_with(crate::generic::DebugConnectTargetRequest {
                    target_id,

                    server,
                })
            }

            #[doc = " Connects to the target device with the given ID. Equivalent to connecting to `TargetService`\n via the corresponding driver node.\n\n Returns `INVALID_ARGS` if `target_id` is greater than or equal to `MAX_TARGETS`.\n May return an error if there is no such target on the bus; otherwise errors will be returned\n when attempting to access the client.\n"]
            pub fn connect_target_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::TwoWayFuture<'_, super::ConnectTarget, ___T>
            where
                ___R: ::fidl_next::Encode<
                        crate::wire::DebugConnectTargetRequest,
                        <___T as ::fidl_next::Transport>::SendBuffer,
                    >,
            {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    799648158518250777,
                    <super::ConnectTarget as ::fidl_next::Method>::FLEXIBILITY,
                    request,
                ))
            }

            #[doc = " Returns the properties of the host SPMI controller.\n"]
            pub fn get_controller_properties(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::GetControllerProperties, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(
                    self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
                        4733781216537150751,
                        <super::GetControllerProperties as ::fidl_next::Method>::FLEXIBILITY,
                        (),
                    ),
                )
            }
        }

        /// The server for the `Debug` protocol.
        #[repr(transparent)]
        pub struct DebugServer<___T: ::fidl_next::Transport> {
            server: ::fidl_next::protocol::Server<___T>,
        }

        impl<___T> DebugServer<___T> where ___T: ::fidl_next::Transport {}
    }
}

#[diagnostic::on_unimplemented(
    note = "If {Self} implements the non-local DebugClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
)]

/// A client handler for the Debug protocol.
///
/// See [`Debug`] for more details.
pub trait DebugLocalClientHandler<
    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
>
{
    fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Debug
where
    ___H: DebugLocalClientHandler<___T>,
    ___T: ::fidl_next::Transport,
{
    async fn on_event(
        handler: &mut ___H,
        mut message: ::fidl_next::Message<___T>,
    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
        match *message.header().ordinal {
            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                if ::core::matches!(
                    message.header().flexibility(),
                    ::fidl_next::protocol::Flexibility::Strict
                ) {
                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                } else {
                    Ok(())
                }
            }
        }
    }
}

#[diagnostic::on_unimplemented(
    note = "If {Self} implements the non-local DebugServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
)]

/// A server handler for the Debug protocol.
///
/// See [`Debug`] for more details.
pub trait DebugLocalServerHandler<
    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
>
{
    #[doc = " Connects to the target device with the given ID. Equivalent to connecting to `TargetService`\n via the corresponding driver node.\n\n Returns `INVALID_ARGS` if `target_id` is greater than or equal to `MAX_TARGETS`.\n May return an error if there is no such target on the bus; otherwise errors will be returned\n when attempting to access the client.\n"]
    fn connect_target(
        &mut self,

        request: ::fidl_next::Request<debug::ConnectTarget, ___T>,

        responder: ::fidl_next::Responder<debug::ConnectTarget, ___T>,
    ) -> impl ::core::future::Future<Output = ()>;

    #[doc = " Returns the properties of the host SPMI controller.\n"]
    fn get_controller_properties(
        &mut self,

        responder: ::fidl_next::Responder<debug::GetControllerProperties, ___T>,
    ) -> impl ::core::future::Future<Output = ()>;

    fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Debug
where
    ___H: DebugLocalServerHandler<___T>,
    ___T: ::fidl_next::Transport,
    for<'de> crate::wire::DebugConnectTargetRequest: ::fidl_next::Decode<
            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
            Constraint = (),
        >,
{
    async fn on_one_way(
        handler: &mut ___H,
        mut message: ::fidl_next::Message<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match *message.header().ordinal {
            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                if ::core::matches!(
                    message.header().flexibility(),
                    ::fidl_next::protocol::Flexibility::Strict
                ) {
                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                } else {
                    Ok(())
                }
            }
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        mut message: ::fidl_next::Message<___T>,
        responder: ::fidl_next::protocol::Responder<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match *message.header().ordinal {
            799648158518250777 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::AsDecoderExt::into_decoded(message) {
                    Ok(decoded) => {
                        handler
                            .connect_target(::fidl_next::Request::from_decoded(decoded), responder)
                            .await;
                        Ok(())
                    }
                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                        ordinal: 799648158518250777,
                        error,
                    }),
                }
            }

            4733781216537150751 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_controller_properties(responder).await;
                Ok(())
            }

            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                if ::core::matches!(
                    message.header().flexibility(),
                    ::fidl_next::protocol::Flexibility::Strict
                ) {
                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                } else {
                    responder
                        .respond_framework_error(
                            ordinal,
                            ::fidl_next::FrameworkError::UnknownMethod,
                        )
                        .expect("encoding a framework error should never fail")
                        .await?;
                    Ok(())
                }
            }
        }
    }
}

/// A client handler for the Debug protocol.
///
/// See [`Debug`] for more details.
pub trait DebugClientHandler<
    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
>
{
    fn on_unknown_interaction(
        &mut self,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Debug
where
    ___H: DebugClientHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_event(
        handler: &mut ___H,
        mut message: ::fidl_next::Message<___T>,
    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
        match *message.header().ordinal {
            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                if ::core::matches!(
                    message.header().flexibility(),
                    ::fidl_next::protocol::Flexibility::Strict
                ) {
                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                } else {
                    Ok(())
                }
            }
        }
    }
}

/// A server handler for the Debug protocol.
///
/// See [`Debug`] for more details.
pub trait DebugServerHandler<
    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
>
{
    #[doc = " Connects to the target device with the given ID. Equivalent to connecting to `TargetService`\n via the corresponding driver node.\n\n Returns `INVALID_ARGS` if `target_id` is greater than or equal to `MAX_TARGETS`.\n May return an error if there is no such target on the bus; otherwise errors will be returned\n when attempting to access the client.\n"]
    fn connect_target(
        &mut self,

        request: ::fidl_next::Request<debug::ConnectTarget, ___T>,

        responder: ::fidl_next::Responder<debug::ConnectTarget, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " Returns the properties of the host SPMI controller.\n"]
    fn get_controller_properties(
        &mut self,

        responder: ::fidl_next::Responder<debug::GetControllerProperties, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Debug
where
    ___H: DebugServerHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
    for<'de> crate::wire::DebugConnectTargetRequest: ::fidl_next::Decode<
            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
            Constraint = (),
        >,
{
    async fn on_one_way(
        handler: &mut ___H,
        mut message: ::fidl_next::Message<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match *message.header().ordinal {
            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                if ::core::matches!(
                    message.header().flexibility(),
                    ::fidl_next::protocol::Flexibility::Strict
                ) {
                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                } else {
                    Ok(())
                }
            }
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        mut message: ::fidl_next::Message<___T>,
        responder: ::fidl_next::protocol::Responder<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match *message.header().ordinal {
            799648158518250777 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::AsDecoderExt::into_decoded(message) {
                    Ok(decoded) => {
                        handler
                            .connect_target(::fidl_next::Request::from_decoded(decoded), responder)
                            .await;
                        Ok(())
                    }
                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                        ordinal: 799648158518250777,
                        error,
                    }),
                }
            }

            4733781216537150751 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_controller_properties(responder).await;
                Ok(())
            }

            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                if ::core::matches!(
                    message.header().flexibility(),
                    ::fidl_next::protocol::Flexibility::Strict
                ) {
                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                } else {
                    responder
                        .respond_framework_error(
                            ordinal,
                            ::fidl_next::FrameworkError::UnknownMethod,
                        )
                        .expect("encoding a framework error should never fail")
                        .await?;
                    Ok(())
                }
            }
        }
    }
}

impl<___T> DebugClientHandler<___T> for ::fidl_next::IgnoreEvents
where
    ___T: ::fidl_next::Transport,
{
    async fn on_unknown_interaction(&mut self, _: u64) {}
}

impl<___H, ___T> DebugLocalClientHandler<___T> for ::fidl_next::Local<___H>
where
    ___H: DebugClientHandler<___T>,
    ___T: ::fidl_next::Transport,
{
    async fn on_unknown_interaction(&mut self, ordinal: u64) {
        ___H::on_unknown_interaction(&mut self.0, ordinal).await
    }
}

impl<___H, ___T> DebugLocalServerHandler<___T> for ::fidl_next::Local<___H>
where
    ___H: DebugServerHandler<___T>,
    ___T: ::fidl_next::Transport,
{
    async fn connect_target(
        &mut self,

        request: ::fidl_next::Request<debug::ConnectTarget, ___T>,

        responder: ::fidl_next::Responder<debug::ConnectTarget, ___T>,
    ) {
        ___H::connect_target(&mut self.0, request, responder).await
    }

    async fn get_controller_properties(
        &mut self,

        responder: ::fidl_next::Responder<debug::GetControllerProperties, ___T>,
    ) {
        ___H::get_controller_properties(&mut self.0, responder).await
    }

    async fn on_unknown_interaction(&mut self, ordinal: u64) {
        ___H::on_unknown_interaction(&mut self.0, ordinal).await
    }
}

/// The type corresponding to the DebugService service.
#[doc = " This service can be used by command-line utilities and tests to connect to any target device on\n the SPMI bus. It is not exposed to drivers.\n"]
#[derive(Debug)]
pub struct DebugService;

impl ::fidl_next::DiscoverableService for DebugService {
    const SERVICE_NAME: &'static str = "fuchsia.hardware.spmi.DebugService";
    const MEMBER_NAMES: &'static [&'static str] = &["device"];
}

impl ::fidl_next::HasServiceRequest<::fidl_next::fuchsia::zx::Channel> for DebugService {}

impl<___C> ::fidl_next::Service<___C> for DebugService
where
    ___C: ::fidl_next::protocol::ServiceConnector<::fidl_next::fuchsia::zx::Channel>,
{
    type Connector = DebugServiceConnector<___C>;
}

/// A strongly-typed service connector for the `DebugService` service.
#[repr(transparent)]
pub struct DebugServiceConnector<___C> {
    #[allow(dead_code)]
    connector: ___C,
}

impl<___C> DebugServiceConnector<___C>
where
    ___C: ::fidl_next::protocol::ServiceConnector<::fidl_next::fuchsia::zx::Channel>,
{
    /// Attempts to connect to the `device` service member.
    pub fn device(
        &self,
        server_end: ::fidl_next::ServerEnd<crate::Debug, ::fidl_next::fuchsia::zx::Channel>,
    ) -> ::core::result::Result<
        (),
        <___C as ::fidl_next::protocol::ServiceConnector<::fidl_next::fuchsia::zx::Channel>>::Error,
    > {
        ::fidl_next::protocol::ServiceConnector::<
                ::fidl_next::fuchsia::zx::Channel
            >::connect_to_member(
                &self.connector,
                "device",
                server_end.into_untyped(),
            )
    }
}

/// A service handler for the `DebugService` service.
pub trait DebugServiceHandler {
    /// Handles an attempt to connect to the `device` member.
    fn device(
        &self,
        server_end: ::fidl_next::ServerEnd<crate::Debug, ::fidl_next::fuchsia::zx::Channel>,
    );
}

impl<___H, ___T> ::fidl_next::DispatchServiceHandler<___H, ___T> for DebugService
where
    ___H: DebugServiceHandler,
    ::fidl_next::fuchsia::zx::Channel: ::fidl_next::InstanceFromServiceTransport<___T>,
{
    fn on_connection(handler: &___H, member: &str, server_end: ___T) {
        use ::fidl_next::InstanceFromServiceTransport;
        match member {
            "device" => handler.device(::fidl_next::ServerEnd::from_untyped(
                ::fidl_next::fuchsia::zx::Channel::from_service_transport(server_end),
            )),

            _ => unreachable!(),
        }
    }
}

/// The type corresponding to the Device protocol.
#[doc = " Each instance of `Device` represents a target/secondary SPMI device on a SPMI bus.\n To support multiple SPMI devices, multiple nodes must be instantiated.\n"]
#[derive(PartialEq, Debug)]
pub struct Device;

impl ::fidl_next::Discoverable for Device {
    const PROTOCOL_NAME: &'static str = "fuchsia.hardware.spmi.Device";
}

#[cfg(target_os = "fuchsia")]
impl ::fidl_next::HasTransport for Device {
    type Transport = ::fidl_next::fuchsia::zx::Channel;
}

pub mod device {
    pub mod prelude {
        pub use crate::{
            Device, DeviceClientHandler, DeviceLocalClientHandler, DeviceLocalServerHandler,
            DeviceServerHandler, device,
        };

        pub use crate::natural::DeviceCancelWatchControllerWriteCommandsRequest;

        pub use crate::natural::DeviceRegisterReadRequest;

        pub use crate::natural::DeviceRegisterWriteRequest;

        pub use crate::natural::DeviceWatchControllerWriteCommandsRequest;

        pub use crate::natural::DeviceCancelWatchControllerWriteCommandsResponse;

        pub use crate::natural::DeviceGetPropertiesResponse;

        pub use crate::natural::DeviceRegisterReadResponse;

        pub use crate::natural::DeviceRegisterWriteResponse;

        pub use crate::natural::DeviceWatchControllerWriteCommandsResponse;

        pub use crate::natural::DriverError;
    }

    pub struct RegisterRead;

    impl ::fidl_next::Method for RegisterRead {
        const ORDINAL: u64 = 7616793777944757;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::Device;

        type Request = crate::wire::DeviceRegisterReadRequest;
    }

    impl ::fidl_next::TwoWayMethod for RegisterRead {
        type Response = ::fidl_next::wire::Result<
            'static,
            crate::wire::DeviceRegisterReadResponse<'static>,
            crate::wire::DriverError,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for RegisterRead {
        type Output = ::core::result::Result<
            crate::generic::DeviceRegisterReadResponse<___R>,
            ::fidl_next::never::Never,
        >;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(crate::generic::DeviceRegisterReadResponse {
                data: response,
            })
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for RegisterRead {
        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct RegisterWrite;

    impl ::fidl_next::Method for RegisterWrite {
        const ORDINAL: u64 = 1044640317848992555;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::Device;

        type Request = crate::wire::DeviceRegisterWriteRequest<'static>;
    }

    impl ::fidl_next::TwoWayMethod for RegisterWrite {
        type Response = ::fidl_next::wire::Result<
            'static,
            crate::wire::DeviceRegisterWriteResponse,
            crate::wire::DriverError,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for RegisterWrite {
        type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for RegisterWrite {
        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct GetProperties;

    impl ::fidl_next::Method for GetProperties {
        const ORDINAL: u64 = 2203507889677991867;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::Device;

        type Request = ::fidl_next::wire::EmptyMessageBody;
    }

    impl ::fidl_next::TwoWayMethod for GetProperties {
        type Response =
            ::fidl_next::wire::Flexible<'static, crate::wire::DeviceGetPropertiesResponse<'static>>;
    }

    impl<___R> ::fidl_next::Respond<___R> for GetProperties {
        type Output = ::fidl_next::Flexible<___R>;

        fn respond(response: ___R) -> Self::Output {
            ::fidl_next::Flexible(response)
        }
    }

    pub struct WatchControllerWriteCommands;

    impl ::fidl_next::Method for WatchControllerWriteCommands {
        const ORDINAL: u64 = 4712819229924853164;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::Device;

        type Request = crate::wire::DeviceWatchControllerWriteCommandsRequest;
    }

    impl ::fidl_next::TwoWayMethod for WatchControllerWriteCommands {
        type Response = ::fidl_next::wire::Result<
            'static,
            crate::wire::DeviceWatchControllerWriteCommandsResponse<'static>,
            crate::wire::DriverError,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for WatchControllerWriteCommands {
        type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for WatchControllerWriteCommands {
        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    pub struct CancelWatchControllerWriteCommands;

    impl ::fidl_next::Method for CancelWatchControllerWriteCommands {
        const ORDINAL: u64 = 5789309704894207008;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::Device;

        type Request = crate::wire::DeviceCancelWatchControllerWriteCommandsRequest;
    }

    impl ::fidl_next::TwoWayMethod for CancelWatchControllerWriteCommands {
        type Response = ::fidl_next::wire::Result<
            'static,
            crate::wire::DeviceCancelWatchControllerWriteCommandsResponse,
            crate::wire::DriverError,
        >;
    }

    impl<___R> ::fidl_next::Respond<___R> for CancelWatchControllerWriteCommands {
        type Output = ::core::result::Result<___R, ::fidl_next::never::Never>;

        fn respond(response: ___R) -> Self::Output {
            ::core::result::Result::Ok(response)
        }
    }

    impl<___R> ::fidl_next::RespondErr<___R> for CancelWatchControllerWriteCommands {
        type Output = ::core::result::Result<::fidl_next::never::Never, ___R>;

        fn respond_err(response: ___R) -> Self::Output {
            ::core::result::Result::Err(response)
        }
    }

    mod ___detail {
        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::Device
        where
            ___T: ::fidl_next::Transport,
        {
            type Client = DeviceClient<___T>;
            type Server = DeviceServer<___T>;
        }

        /// The client for the `Device` protocol.
        #[repr(transparent)]
        pub struct DeviceClient<___T: ::fidl_next::Transport> {
            #[allow(dead_code)]
            client: ::fidl_next::protocol::Client<___T>,
        }

        impl<___T> DeviceClient<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            #[doc = " Issue register read commands to the SPMI device.\n The implementation may choose which SPMI variation (e.g. extended, long) to use.\n When successful, it returns `size_bytes` in `data` read contiguously starting from\n `address` in the device.\n"]
            pub fn register_read(
                &self,

                address: impl ::fidl_next::Encode<
                    ::fidl_next::wire::Uint16,
                    <___T as ::fidl_next::Transport>::SendBuffer,
                >,

                size_bytes: impl ::fidl_next::Encode<
                    ::fidl_next::wire::Uint32,
                    <___T as ::fidl_next::Transport>::SendBuffer,
                >,
            ) -> ::fidl_next::TwoWayFuture<'_, super::RegisterRead, ___T>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.register_read_with(crate::generic::DeviceRegisterReadRequest {
                    address,

                    size_bytes,
                })
            }

            #[doc = " Issue register read commands to the SPMI device.\n The implementation may choose which SPMI variation (e.g. extended, long) to use.\n When successful, it returns `size_bytes` in `data` read contiguously starting from\n `address` in the device.\n"]
            pub fn register_read_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::TwoWayFuture<'_, super::RegisterRead, ___T>
            where
                ___R: ::fidl_next::Encode<
                        crate::wire::DeviceRegisterReadRequest,
                        <___T as ::fidl_next::Transport>::SendBuffer,
                    >,
            {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    7616793777944757,
                    <super::RegisterRead as ::fidl_next::Method>::FLEXIBILITY,
                    request,
                ))
            }

            #[doc = " Issue register write commands to the SPMI device.\n The implementation may choose which SPMI variation (e.g. extended, long) to use.\n When this command is successful, `data` will be written contiguously starting from\n `address` in the device.\n"]
            pub fn register_write(
                &self,

                address: impl ::fidl_next::Encode<
                    ::fidl_next::wire::Uint16,
                    <___T as ::fidl_next::Transport>::SendBuffer,
                >,

                data: impl ::fidl_next::Encode<
                    ::fidl_next::wire::Vector<'static, u8>,
                    <___T as ::fidl_next::Transport>::SendBuffer,
                >,
            ) -> ::fidl_next::TwoWayFuture<'_, super::RegisterWrite, ___T>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.register_write_with(crate::generic::DeviceRegisterWriteRequest {
                    address,

                    data,
                })
            }

            #[doc = " Issue register write commands to the SPMI device.\n The implementation may choose which SPMI variation (e.g. extended, long) to use.\n When this command is successful, `data` will be written contiguously starting from\n `address` in the device.\n"]
            pub fn register_write_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::TwoWayFuture<'_, super::RegisterWrite, ___T>
            where
                ___R: ::fidl_next::Encode<
                        crate::wire::DeviceRegisterWriteRequest<'static>,
                        <___T as ::fidl_next::Transport>::SendBuffer,
                    >,
            {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    1044640317848992555,
                    <super::RegisterWrite as ::fidl_next::Method>::FLEXIBILITY,
                    request,
                ))
            }

            #[doc = " Get the properties of the SPMI device.\n"]
            pub fn get_properties(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::GetProperties, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(
                    self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
                        2203507889677991867,
                        <super::GetProperties as ::fidl_next::Method>::FLEXIBILITY,
                        (),
                    ),
                )
            }

            #[doc = " Hanging-get method to receive controller write commands from the device. `address` and\n `size` specify the register range to monitor for commands. Multiple overlapping calls to\n this method are not allowed.\n Returns `INVALID_ARGS` if `address` or `size` are invalid, or `BAD_STATE` if another call\n is pending for this register range. Returns `CANCELED` if\n `CancelWatchControllerWriteCommands()` was called for this register range.\n\n If this method is meant to keep the system awake (prevents suspension) while watch is setup,\n use the passed-in `setup_wake_lease` `LeaseToken`. Then, when the watch is triggered this\n method will return a second `wake_lease` `LeaseToken` to prevent suspension.\n\n These keep alive wake lease tokens are provided by the Power Framework\'s System Activity\n Governor. A driver supporting keep alive must be able to get `wake_lease` from System\n Activity Governor.\n\n When `wake_lease` is closed, then the created wake lease keeping the system from suspending\n at the time of watch triggering is dropped. Hence, to guarantee that the system is not\n suspended by the Power Framework a client must either keep this `wake_lease` for as long as\n the system needs to stay awake, or a client must get its own wake lease from the Power\n Framework before it drops `wake_lease` to prevent suspension.\n"]
            pub fn watch_controller_write_commands(
                &self,

                address: impl ::fidl_next::Encode<u8, <___T as ::fidl_next::Transport>::SendBuffer>,

                size: impl ::fidl_next::Encode<
                    ::fidl_next::wire::Uint16,
                    <___T as ::fidl_next::Transport>::SendBuffer,
                >,

                setup_wake_lease: impl ::fidl_next::Encode<
                    ::fidl_next::wire::fuchsia::OptionalEventPair,
                    <___T as ::fidl_next::Transport>::SendBuffer,
                >,
            ) -> ::fidl_next::TwoWayFuture<'_, super::WatchControllerWriteCommands, ___T>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::fuchsia::HandleEncoder,
            {
                self.watch_controller_write_commands_with(
                    crate::generic::DeviceWatchControllerWriteCommandsRequest {
                        address,

                        size,

                        setup_wake_lease,
                    },
                )
            }

            #[doc = " Hanging-get method to receive controller write commands from the device. `address` and\n `size` specify the register range to monitor for commands. Multiple overlapping calls to\n this method are not allowed.\n Returns `INVALID_ARGS` if `address` or `size` are invalid, or `BAD_STATE` if another call\n is pending for this register range. Returns `CANCELED` if\n `CancelWatchControllerWriteCommands()` was called for this register range.\n\n If this method is meant to keep the system awake (prevents suspension) while watch is setup,\n use the passed-in `setup_wake_lease` `LeaseToken`. Then, when the watch is triggered this\n method will return a second `wake_lease` `LeaseToken` to prevent suspension.\n\n These keep alive wake lease tokens are provided by the Power Framework\'s System Activity\n Governor. A driver supporting keep alive must be able to get `wake_lease` from System\n Activity Governor.\n\n When `wake_lease` is closed, then the created wake lease keeping the system from suspending\n at the time of watch triggering is dropped. Hence, to guarantee that the system is not\n suspended by the Power Framework a client must either keep this `wake_lease` for as long as\n the system needs to stay awake, or a client must get its own wake lease from the Power\n Framework before it drops `wake_lease` to prevent suspension.\n"]
            pub fn watch_controller_write_commands_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::TwoWayFuture<'_, super::WatchControllerWriteCommands, ___T>
            where
                ___R: ::fidl_next::Encode<
                        crate::wire::DeviceWatchControllerWriteCommandsRequest,
                        <___T as ::fidl_next::Transport>::SendBuffer,
                    >,
            {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    4712819229924853164,
                    <super::WatchControllerWriteCommands as ::fidl_next::Method>::FLEXIBILITY,
                    request,
                ))
            }

            #[doc = " Cancels an pending call to `WatchControllerWriteCommands`. `address` and `size` must\n exactly match a previous call to `WatchControllerWriteCommands()`, otherwise `NOT_FOUND`\n is returned.\n"]
            pub fn cancel_watch_controller_write_commands(
                &self,

                address: impl ::fidl_next::Encode<u8, <___T as ::fidl_next::Transport>::SendBuffer>,

                size: impl ::fidl_next::Encode<
                    ::fidl_next::wire::Uint16,
                    <___T as ::fidl_next::Transport>::SendBuffer,
                >,
            ) -> ::fidl_next::TwoWayFuture<'_, super::CancelWatchControllerWriteCommands, ___T>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.cancel_watch_controller_write_commands_with(
                    crate::generic::DeviceCancelWatchControllerWriteCommandsRequest {
                        address,

                        size,
                    },
                )
            }

            #[doc = " Cancels an pending call to `WatchControllerWriteCommands`. `address` and `size` must\n exactly match a previous call to `WatchControllerWriteCommands()`, otherwise `NOT_FOUND`\n is returned.\n"]
            pub fn cancel_watch_controller_write_commands_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::TwoWayFuture<'_, super::CancelWatchControllerWriteCommands, ___T>
            where
                ___R: ::fidl_next::Encode<
                        crate::wire::DeviceCancelWatchControllerWriteCommandsRequest,
                        <___T as ::fidl_next::Transport>::SendBuffer,
                    >,
            {
                ::fidl_next::TwoWayFuture::from_untyped(self.client.send_two_way(
                    5789309704894207008,
                    <super::CancelWatchControllerWriteCommands as ::fidl_next::Method>::FLEXIBILITY,
                    request,
                ))
            }
        }

        /// The server for the `Device` protocol.
        #[repr(transparent)]
        pub struct DeviceServer<___T: ::fidl_next::Transport> {
            server: ::fidl_next::protocol::Server<___T>,
        }

        impl<___T> DeviceServer<___T> where ___T: ::fidl_next::Transport {}
    }
}

#[diagnostic::on_unimplemented(
    note = "If {Self} implements the non-local DeviceClientHandler trait, use `spawn_as_local` or the `Local` adapter type"
)]

/// A client handler for the Device protocol.
///
/// See [`Device`] for more details.
pub trait DeviceLocalClientHandler<
    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
>
{
    fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::DispatchLocalClientMessage<___H, ___T> for Device
where
    ___H: DeviceLocalClientHandler<___T>,
    ___T: ::fidl_next::Transport,
{
    async fn on_event(
        handler: &mut ___H,
        mut message: ::fidl_next::Message<___T>,
    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
        match *message.header().ordinal {
            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                if ::core::matches!(
                    message.header().flexibility(),
                    ::fidl_next::protocol::Flexibility::Strict
                ) {
                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                } else {
                    Ok(())
                }
            }
        }
    }
}

#[diagnostic::on_unimplemented(
    note = "If {Self} implements the non-local DeviceServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
)]

/// A server handler for the Device protocol.
///
/// See [`Device`] for more details.
pub trait DeviceLocalServerHandler<
    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
>
{
    #[doc = " Issue register read commands to the SPMI device.\n The implementation may choose which SPMI variation (e.g. extended, long) to use.\n When successful, it returns `size_bytes` in `data` read contiguously starting from\n `address` in the device.\n"]
    fn register_read(
        &mut self,

        request: ::fidl_next::Request<device::RegisterRead, ___T>,

        responder: ::fidl_next::Responder<device::RegisterRead, ___T>,
    ) -> impl ::core::future::Future<Output = ()>;

    #[doc = " Issue register write commands to the SPMI device.\n The implementation may choose which SPMI variation (e.g. extended, long) to use.\n When this command is successful, `data` will be written contiguously starting from\n `address` in the device.\n"]
    fn register_write(
        &mut self,

        request: ::fidl_next::Request<device::RegisterWrite, ___T>,

        responder: ::fidl_next::Responder<device::RegisterWrite, ___T>,
    ) -> impl ::core::future::Future<Output = ()>;

    #[doc = " Get the properties of the SPMI device.\n"]
    fn get_properties(
        &mut self,

        responder: ::fidl_next::Responder<device::GetProperties, ___T>,
    ) -> impl ::core::future::Future<Output = ()>;

    #[doc = " Hanging-get method to receive controller write commands from the device. `address` and\n `size` specify the register range to monitor for commands. Multiple overlapping calls to\n this method are not allowed.\n Returns `INVALID_ARGS` if `address` or `size` are invalid, or `BAD_STATE` if another call\n is pending for this register range. Returns `CANCELED` if\n `CancelWatchControllerWriteCommands()` was called for this register range.\n\n If this method is meant to keep the system awake (prevents suspension) while watch is setup,\n use the passed-in `setup_wake_lease` `LeaseToken`. Then, when the watch is triggered this\n method will return a second `wake_lease` `LeaseToken` to prevent suspension.\n\n These keep alive wake lease tokens are provided by the Power Framework\'s System Activity\n Governor. A driver supporting keep alive must be able to get `wake_lease` from System\n Activity Governor.\n\n When `wake_lease` is closed, then the created wake lease keeping the system from suspending\n at the time of watch triggering is dropped. Hence, to guarantee that the system is not\n suspended by the Power Framework a client must either keep this `wake_lease` for as long as\n the system needs to stay awake, or a client must get its own wake lease from the Power\n Framework before it drops `wake_lease` to prevent suspension.\n"]
    fn watch_controller_write_commands(
        &mut self,

        request: ::fidl_next::Request<device::WatchControllerWriteCommands, ___T>,

        responder: ::fidl_next::Responder<device::WatchControllerWriteCommands, ___T>,
    ) -> impl ::core::future::Future<Output = ()>;

    #[doc = " Cancels an pending call to `WatchControllerWriteCommands`. `address` and `size` must\n exactly match a previous call to `WatchControllerWriteCommands()`, otherwise `NOT_FOUND`\n is returned.\n"]
    fn cancel_watch_controller_write_commands(
        &mut self,

        request: ::fidl_next::Request<device::CancelWatchControllerWriteCommands, ___T>,

        responder: ::fidl_next::Responder<device::CancelWatchControllerWriteCommands, ___T>,
    ) -> impl ::core::future::Future<Output = ()>;

    fn on_unknown_interaction(&mut self, ordinal: u64) -> impl ::core::future::Future<Output = ()> {
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::DispatchLocalServerMessage<___H, ___T> for Device
where
    ___H: DeviceLocalServerHandler<___T>,
    ___T: ::fidl_next::Transport,
    for<'de> crate::wire::DeviceRegisterReadRequest: ::fidl_next::Decode<
            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
            Constraint = (),
        >,
    for<'de> crate::wire::DeviceRegisterWriteRequest<'de>: ::fidl_next::Decode<
            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
            Constraint = (),
        >,
    for<'de> crate::wire::DeviceWatchControllerWriteCommandsRequest: ::fidl_next::Decode<
            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
            Constraint = (),
        >,
    for<'de> crate::wire::DeviceCancelWatchControllerWriteCommandsRequest: ::fidl_next::Decode<
            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
            Constraint = (),
        >,
{
    async fn on_one_way(
        handler: &mut ___H,
        mut message: ::fidl_next::Message<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match *message.header().ordinal {
            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                if ::core::matches!(
                    message.header().flexibility(),
                    ::fidl_next::protocol::Flexibility::Strict
                ) {
                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                } else {
                    Ok(())
                }
            }
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        mut message: ::fidl_next::Message<___T>,
        responder: ::fidl_next::protocol::Responder<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match *message.header().ordinal {
            7616793777944757 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::AsDecoderExt::into_decoded(message) {
                    Ok(decoded) => {
                        handler
                            .register_read(::fidl_next::Request::from_decoded(decoded), responder)
                            .await;
                        Ok(())
                    }
                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                        ordinal: 7616793777944757,
                        error,
                    }),
                }
            }

            1044640317848992555 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::AsDecoderExt::into_decoded(message) {
                    Ok(decoded) => {
                        handler
                            .register_write(::fidl_next::Request::from_decoded(decoded), responder)
                            .await;
                        Ok(())
                    }
                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                        ordinal: 1044640317848992555,
                        error,
                    }),
                }
            }

            2203507889677991867 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_properties(responder).await;
                Ok(())
            }

            4712819229924853164 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::AsDecoderExt::into_decoded(message) {
                    Ok(decoded) => {
                        handler
                            .watch_controller_write_commands(
                                ::fidl_next::Request::from_decoded(decoded),
                                responder,
                            )
                            .await;
                        Ok(())
                    }
                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                        ordinal: 4712819229924853164,
                        error,
                    }),
                }
            }

            5789309704894207008 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::AsDecoderExt::into_decoded(message) {
                    Ok(decoded) => {
                        handler
                            .cancel_watch_controller_write_commands(
                                ::fidl_next::Request::from_decoded(decoded),
                                responder,
                            )
                            .await;
                        Ok(())
                    }
                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                        ordinal: 5789309704894207008,
                        error,
                    }),
                }
            }

            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                if ::core::matches!(
                    message.header().flexibility(),
                    ::fidl_next::protocol::Flexibility::Strict
                ) {
                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                } else {
                    responder
                        .respond_framework_error(
                            ordinal,
                            ::fidl_next::FrameworkError::UnknownMethod,
                        )
                        .expect("encoding a framework error should never fail")
                        .await?;
                    Ok(())
                }
            }
        }
    }
}

/// A client handler for the Device protocol.
///
/// See [`Device`] for more details.
pub trait DeviceClientHandler<
    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
>
{
    fn on_unknown_interaction(
        &mut self,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Device
where
    ___H: DeviceClientHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
{
    async fn on_event(
        handler: &mut ___H,
        mut message: ::fidl_next::Message<___T>,
    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
        match *message.header().ordinal {
            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                if ::core::matches!(
                    message.header().flexibility(),
                    ::fidl_next::protocol::Flexibility::Strict
                ) {
                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                } else {
                    Ok(())
                }
            }
        }
    }
}

/// A server handler for the Device protocol.
///
/// See [`Device`] for more details.
pub trait DeviceServerHandler<
    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
>
{
    #[doc = " Issue register read commands to the SPMI device.\n The implementation may choose which SPMI variation (e.g. extended, long) to use.\n When successful, it returns `size_bytes` in `data` read contiguously starting from\n `address` in the device.\n"]
    fn register_read(
        &mut self,

        request: ::fidl_next::Request<device::RegisterRead, ___T>,

        responder: ::fidl_next::Responder<device::RegisterRead, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " Issue register write commands to the SPMI device.\n The implementation may choose which SPMI variation (e.g. extended, long) to use.\n When this command is successful, `data` will be written contiguously starting from\n `address` in the device.\n"]
    fn register_write(
        &mut self,

        request: ::fidl_next::Request<device::RegisterWrite, ___T>,

        responder: ::fidl_next::Responder<device::RegisterWrite, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " Get the properties of the SPMI device.\n"]
    fn get_properties(
        &mut self,

        responder: ::fidl_next::Responder<device::GetProperties, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " Hanging-get method to receive controller write commands from the device. `address` and\n `size` specify the register range to monitor for commands. Multiple overlapping calls to\n this method are not allowed.\n Returns `INVALID_ARGS` if `address` or `size` are invalid, or `BAD_STATE` if another call\n is pending for this register range. Returns `CANCELED` if\n `CancelWatchControllerWriteCommands()` was called for this register range.\n\n If this method is meant to keep the system awake (prevents suspension) while watch is setup,\n use the passed-in `setup_wake_lease` `LeaseToken`. Then, when the watch is triggered this\n method will return a second `wake_lease` `LeaseToken` to prevent suspension.\n\n These keep alive wake lease tokens are provided by the Power Framework\'s System Activity\n Governor. A driver supporting keep alive must be able to get `wake_lease` from System\n Activity Governor.\n\n When `wake_lease` is closed, then the created wake lease keeping the system from suspending\n at the time of watch triggering is dropped. Hence, to guarantee that the system is not\n suspended by the Power Framework a client must either keep this `wake_lease` for as long as\n the system needs to stay awake, or a client must get its own wake lease from the Power\n Framework before it drops `wake_lease` to prevent suspension.\n"]
    fn watch_controller_write_commands(
        &mut self,

        request: ::fidl_next::Request<device::WatchControllerWriteCommands, ___T>,

        responder: ::fidl_next::Responder<device::WatchControllerWriteCommands, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    #[doc = " Cancels an pending call to `WatchControllerWriteCommands`. `address` and `size` must\n exactly match a previous call to `WatchControllerWriteCommands()`, otherwise `NOT_FOUND`\n is returned.\n"]
    fn cancel_watch_controller_write_commands(
        &mut self,

        request: ::fidl_next::Request<device::CancelWatchControllerWriteCommands, ___T>,

        responder: ::fidl_next::Responder<device::CancelWatchControllerWriteCommands, ___T>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;

    fn on_unknown_interaction(
        &mut self,
        ordinal: u64,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send {
        ::core::future::ready(())
    }
}

impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Device
where
    ___H: DeviceServerHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
    for<'de> crate::wire::DeviceRegisterReadRequest: ::fidl_next::Decode<
            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
            Constraint = (),
        >,
    for<'de> crate::wire::DeviceRegisterWriteRequest<'de>: ::fidl_next::Decode<
            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
            Constraint = (),
        >,
    for<'de> crate::wire::DeviceWatchControllerWriteCommandsRequest: ::fidl_next::Decode<
            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
            Constraint = (),
        >,
    for<'de> crate::wire::DeviceCancelWatchControllerWriteCommandsRequest: ::fidl_next::Decode<
            <<___T as ::fidl_next::Transport>::RecvBuffer as ::fidl_next::AsDecoder<'de>>::Decoder,
            Constraint = (),
        >,
{
    async fn on_one_way(
        handler: &mut ___H,
        mut message: ::fidl_next::Message<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match *message.header().ordinal {
            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                if ::core::matches!(
                    message.header().flexibility(),
                    ::fidl_next::protocol::Flexibility::Strict
                ) {
                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                } else {
                    Ok(())
                }
            }
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        mut message: ::fidl_next::Message<___T>,
        responder: ::fidl_next::protocol::Responder<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match *message.header().ordinal {
            7616793777944757 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::AsDecoderExt::into_decoded(message) {
                    Ok(decoded) => {
                        handler
                            .register_read(::fidl_next::Request::from_decoded(decoded), responder)
                            .await;
                        Ok(())
                    }
                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                        ordinal: 7616793777944757,
                        error,
                    }),
                }
            }

            1044640317848992555 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::AsDecoderExt::into_decoded(message) {
                    Ok(decoded) => {
                        handler
                            .register_write(::fidl_next::Request::from_decoded(decoded), responder)
                            .await;
                        Ok(())
                    }
                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                        ordinal: 1044640317848992555,
                        error,
                    }),
                }
            }

            2203507889677991867 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.get_properties(responder).await;
                Ok(())
            }

            4712819229924853164 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::AsDecoderExt::into_decoded(message) {
                    Ok(decoded) => {
                        handler
                            .watch_controller_write_commands(
                                ::fidl_next::Request::from_decoded(decoded),
                                responder,
                            )
                            .await;
                        Ok(())
                    }
                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                        ordinal: 4712819229924853164,
                        error,
                    }),
                }
            }

            5789309704894207008 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::AsDecoderExt::into_decoded(message) {
                    Ok(decoded) => {
                        handler
                            .cancel_watch_controller_write_commands(
                                ::fidl_next::Request::from_decoded(decoded),
                                responder,
                            )
                            .await;
                        Ok(())
                    }
                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                        ordinal: 5789309704894207008,
                        error,
                    }),
                }
            }

            ordinal => {
                handler.on_unknown_interaction(ordinal).await;
                if ::core::matches!(
                    message.header().flexibility(),
                    ::fidl_next::protocol::Flexibility::Strict
                ) {
                    Err(::fidl_next::ProtocolError::UnknownOrdinal(ordinal))
                } else {
                    responder
                        .respond_framework_error(
                            ordinal,
                            ::fidl_next::FrameworkError::UnknownMethod,
                        )
                        .expect("encoding a framework error should never fail")
                        .await?;
                    Ok(())
                }
            }
        }
    }
}

impl<___T> DeviceClientHandler<___T> for ::fidl_next::IgnoreEvents
where
    ___T: ::fidl_next::Transport,
{
    async fn on_unknown_interaction(&mut self, _: u64) {}
}

impl<___H, ___T> DeviceLocalClientHandler<___T> for ::fidl_next::Local<___H>
where
    ___H: DeviceClientHandler<___T>,
    ___T: ::fidl_next::Transport,
{
    async fn on_unknown_interaction(&mut self, ordinal: u64) {
        ___H::on_unknown_interaction(&mut self.0, ordinal).await
    }
}

impl<___H, ___T> DeviceLocalServerHandler<___T> for ::fidl_next::Local<___H>
where
    ___H: DeviceServerHandler<___T>,
    ___T: ::fidl_next::Transport,
{
    async fn register_read(
        &mut self,

        request: ::fidl_next::Request<device::RegisterRead, ___T>,

        responder: ::fidl_next::Responder<device::RegisterRead, ___T>,
    ) {
        ___H::register_read(&mut self.0, request, responder).await
    }

    async fn register_write(
        &mut self,

        request: ::fidl_next::Request<device::RegisterWrite, ___T>,

        responder: ::fidl_next::Responder<device::RegisterWrite, ___T>,
    ) {
        ___H::register_write(&mut self.0, request, responder).await
    }

    async fn get_properties(
        &mut self,

        responder: ::fidl_next::Responder<device::GetProperties, ___T>,
    ) {
        ___H::get_properties(&mut self.0, responder).await
    }

    async fn watch_controller_write_commands(
        &mut self,

        request: ::fidl_next::Request<device::WatchControllerWriteCommands, ___T>,

        responder: ::fidl_next::Responder<device::WatchControllerWriteCommands, ___T>,
    ) {
        ___H::watch_controller_write_commands(&mut self.0, request, responder).await
    }

    async fn cancel_watch_controller_write_commands(
        &mut self,

        request: ::fidl_next::Request<device::CancelWatchControllerWriteCommands, ___T>,

        responder: ::fidl_next::Responder<device::CancelWatchControllerWriteCommands, ___T>,
    ) {
        ___H::cancel_watch_controller_write_commands(&mut self.0, request, responder).await
    }

    async fn on_unknown_interaction(&mut self, ordinal: u64) {
        ___H::on_unknown_interaction(&mut self.0, ordinal).await
    }
}

/// The type corresponding to the SubTargetService service.
#[doc = " This service represents a sub-target device within an SPMI target. Clients have access to a\n subset of the SPMI register range as determined by the controller driver.\n"]
#[derive(Debug)]
pub struct SubTargetService;

impl ::fidl_next::DiscoverableService for SubTargetService {
    const SERVICE_NAME: &'static str = "fuchsia.hardware.spmi.SubTargetService";
    const MEMBER_NAMES: &'static [&'static str] = &["device"];
}

impl ::fidl_next::HasServiceRequest<::fidl_next::fuchsia::zx::Channel> for SubTargetService {}

impl<___C> ::fidl_next::Service<___C> for SubTargetService
where
    ___C: ::fidl_next::protocol::ServiceConnector<::fidl_next::fuchsia::zx::Channel>,
{
    type Connector = SubTargetServiceConnector<___C>;
}

/// A strongly-typed service connector for the `SubTargetService` service.
#[repr(transparent)]
pub struct SubTargetServiceConnector<___C> {
    #[allow(dead_code)]
    connector: ___C,
}

impl<___C> SubTargetServiceConnector<___C>
where
    ___C: ::fidl_next::protocol::ServiceConnector<::fidl_next::fuchsia::zx::Channel>,
{
    /// Attempts to connect to the `device` service member.
    pub fn device(
        &self,
        server_end: ::fidl_next::ServerEnd<crate::Device, ::fidl_next::fuchsia::zx::Channel>,
    ) -> ::core::result::Result<
        (),
        <___C as ::fidl_next::protocol::ServiceConnector<::fidl_next::fuchsia::zx::Channel>>::Error,
    > {
        ::fidl_next::protocol::ServiceConnector::<
                ::fidl_next::fuchsia::zx::Channel
            >::connect_to_member(
                &self.connector,
                "device",
                server_end.into_untyped(),
            )
    }
}

/// A service handler for the `SubTargetService` service.
pub trait SubTargetServiceHandler {
    /// Handles an attempt to connect to the `device` member.
    fn device(
        &self,
        server_end: ::fidl_next::ServerEnd<crate::Device, ::fidl_next::fuchsia::zx::Channel>,
    );
}

impl<___H, ___T> ::fidl_next::DispatchServiceHandler<___H, ___T> for SubTargetService
where
    ___H: SubTargetServiceHandler,
    ::fidl_next::fuchsia::zx::Channel: ::fidl_next::InstanceFromServiceTransport<___T>,
{
    fn on_connection(handler: &___H, member: &str, server_end: ___T) {
        use ::fidl_next::InstanceFromServiceTransport;
        match member {
            "device" => handler.device(::fidl_next::ServerEnd::from_untyped(
                ::fidl_next::fuchsia::zx::Channel::from_service_transport(server_end),
            )),

            _ => unreachable!(),
        }
    }
}

/// The type corresponding to the TargetService service.
#[doc = " This service represents an SPMI target device. Clients have access to the entire SPMI register\n range.\n"]
#[derive(Debug)]
pub struct TargetService;

impl ::fidl_next::DiscoverableService for TargetService {
    const SERVICE_NAME: &'static str = "fuchsia.hardware.spmi.TargetService";
    const MEMBER_NAMES: &'static [&'static str] = &["device"];
}

impl ::fidl_next::HasServiceRequest<::fidl_next::fuchsia::zx::Channel> for TargetService {}

impl<___C> ::fidl_next::Service<___C> for TargetService
where
    ___C: ::fidl_next::protocol::ServiceConnector<::fidl_next::fuchsia::zx::Channel>,
{
    type Connector = TargetServiceConnector<___C>;
}

/// A strongly-typed service connector for the `TargetService` service.
#[repr(transparent)]
pub struct TargetServiceConnector<___C> {
    #[allow(dead_code)]
    connector: ___C,
}

impl<___C> TargetServiceConnector<___C>
where
    ___C: ::fidl_next::protocol::ServiceConnector<::fidl_next::fuchsia::zx::Channel>,
{
    /// Attempts to connect to the `device` service member.
    pub fn device(
        &self,
        server_end: ::fidl_next::ServerEnd<crate::Device, ::fidl_next::fuchsia::zx::Channel>,
    ) -> ::core::result::Result<
        (),
        <___C as ::fidl_next::protocol::ServiceConnector<::fidl_next::fuchsia::zx::Channel>>::Error,
    > {
        ::fidl_next::protocol::ServiceConnector::<
                ::fidl_next::fuchsia::zx::Channel
            >::connect_to_member(
                &self.connector,
                "device",
                server_end.into_untyped(),
            )
    }
}

/// A service handler for the `TargetService` service.
pub trait TargetServiceHandler {
    /// Handles an attempt to connect to the `device` member.
    fn device(
        &self,
        server_end: ::fidl_next::ServerEnd<crate::Device, ::fidl_next::fuchsia::zx::Channel>,
    );
}

impl<___H, ___T> ::fidl_next::DispatchServiceHandler<___H, ___T> for TargetService
where
    ___H: TargetServiceHandler,
    ::fidl_next::fuchsia::zx::Channel: ::fidl_next::InstanceFromServiceTransport<___T>,
{
    fn on_connection(handler: &___H, member: &str, server_end: ___T) {
        use ::fidl_next::InstanceFromServiceTransport;
        match member {
            "device" => handler.device(::fidl_next::ServerEnd::from_untyped(
                ::fidl_next::fuchsia::zx::Channel::from_service_transport(server_end),
            )),

            _ => unreachable!(),
        }
    }
}

pub use fidl_next_common_fuchsia_hardware_spmi::*;