fidl_next_common_fuchsia_power_system/

fidl_next_common_fuchsia_power_system.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 {

    #[doc = " Errors returned by `ActivityGovernor/AcquireWakeLease`.\n"]
    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    #[repr(u32)]
    pub enum AcquireWakeLeaseError {
        Internal = 1,
        InvalidName = 2,
        UnknownOrdinal_(u32) = 3,
    }
    impl ::std::convert::From<u32> for AcquireWakeLeaseError {
        fn from(value: u32) -> Self {
            match value {
                1 => Self::Internal,
                2 => Self::InvalidName,

                _ => Self::UnknownOrdinal_(value),
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::AcquireWakeLeaseError, ___E>
        for AcquireWakeLeaseError
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::AcquireWakeLeaseError>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::Encode::encode(&self, encoder, out, ())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::AcquireWakeLeaseError, ___E>
        for &'a AcquireWakeLeaseError
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::AcquireWakeLeaseError>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::AcquireWakeLeaseError { value } = out);
            let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
                AcquireWakeLeaseError::Internal => 1,

                AcquireWakeLeaseError::InvalidName => 2,

                AcquireWakeLeaseError::UnknownOrdinal_(value) => value,
            }));

            Ok(())
        }
    }

    impl ::core::convert::From<crate::wire::AcquireWakeLeaseError> for AcquireWakeLeaseError {
        fn from(wire: crate::wire::AcquireWakeLeaseError) -> Self {
            match u32::from(wire.value) {
                1 => Self::Internal,

                2 => Self::InvalidName,

                value => Self::UnknownOrdinal_(value),
            }
        }
    }

    impl ::fidl_next::FromWire<crate::wire::AcquireWakeLeaseError> for AcquireWakeLeaseError {
        #[inline]
        fn from_wire(wire: crate::wire::AcquireWakeLeaseError) -> Self {
            Self::from(wire)
        }
    }

    impl ::fidl_next::FromWireRef<crate::wire::AcquireWakeLeaseError> for AcquireWakeLeaseError {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::AcquireWakeLeaseError) -> Self {
            Self::from(*wire)
        }
    }

    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ActivityGovernorAcquireWakeLeaseRequest {
        pub name: ::std::string::String,
    }

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

                } = out_;
            }

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

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

            Ok(())
        }
    }

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

                } = out_;
            }

            ::fidl_next::Encode::encode(&self.name, encoder_, name, 64)?;

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

            Ok(())
        }
    }

    unsafe impl<___E>
        ::fidl_next::EncodeOption<
            ::fidl_next::wire::Box<
                'static,
                crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'static>,
            >,
            ___E,
        > for ActivityGovernorAcquireWakeLeaseRequest
    where
        ___E: ::fidl_next::Encoder + ?Sized,
        ActivityGovernorAcquireWakeLeaseRequest: ::fidl_next::Encode<crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'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::ActivityGovernorAcquireWakeLeaseRequest<'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(())
        }
    }

    unsafe impl<'a, ___E>
        ::fidl_next::EncodeOption<
            ::fidl_next::wire::Box<
                'static,
                crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'static>,
            >,
            ___E,
        > for &'a ActivityGovernorAcquireWakeLeaseRequest
    where
        ___E: ::fidl_next::Encoder + ?Sized,
        &'a ActivityGovernorAcquireWakeLeaseRequest: ::fidl_next::Encode<crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'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::ActivityGovernorAcquireWakeLeaseRequest<'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::ActivityGovernorAcquireWakeLeaseRequest<'de>>
        for ActivityGovernorAcquireWakeLeaseRequest
    {
        #[inline]
        fn from_wire(wire: crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'de>) -> Self {
            Self { name: ::fidl_next::FromWire::from_wire(wire.name) }
        }
    }

    impl<'de> ::fidl_next::FromWireRef<crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'de>>
        for ActivityGovernorAcquireWakeLeaseRequest
    {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::ActivityGovernorAcquireWakeLeaseRequest<'de>) -> Self {
            Self { name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name) }
        }
    }

    #[doc = " Error codes for responses from `RegisterSuspendBlocker` in\n [`fuchsia.power.system/ActivityGovernor`].\n"]
    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    #[repr(u32)]
    pub enum RegisterSuspendBlockerError {
        Internal = 1,
        InvalidArgs = 2,
        UnknownOrdinal_(u32) = 3,
    }
    impl ::std::convert::From<u32> for RegisterSuspendBlockerError {
        fn from(value: u32) -> Self {
            match value {
                1 => Self::Internal,
                2 => Self::InvalidArgs,

                _ => Self::UnknownOrdinal_(value),
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::RegisterSuspendBlockerError, ___E>
        for RegisterSuspendBlockerError
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::RegisterSuspendBlockerError>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::Encode::encode(&self, encoder, out, ())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::RegisterSuspendBlockerError, ___E>
        for &'a RegisterSuspendBlockerError
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::RegisterSuspendBlockerError>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::RegisterSuspendBlockerError { value } = out);
            let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
                RegisterSuspendBlockerError::Internal => 1,

                RegisterSuspendBlockerError::InvalidArgs => 2,

                RegisterSuspendBlockerError::UnknownOrdinal_(value) => value,
            }));

            Ok(())
        }
    }

    impl ::core::convert::From<crate::wire::RegisterSuspendBlockerError>
        for RegisterSuspendBlockerError
    {
        fn from(wire: crate::wire::RegisterSuspendBlockerError) -> Self {
            match u32::from(wire.value) {
                1 => Self::Internal,

                2 => Self::InvalidArgs,

                value => Self::UnknownOrdinal_(value),
            }
        }
    }

    impl ::fidl_next::FromWire<crate::wire::RegisterSuspendBlockerError>
        for RegisterSuspendBlockerError
    {
        #[inline]
        fn from_wire(wire: crate::wire::RegisterSuspendBlockerError) -> Self {
            Self::from(wire)
        }
    }

    impl ::fidl_next::FromWireRef<crate::wire::RegisterSuspendBlockerError>
        for RegisterSuspendBlockerError
    {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::RegisterSuspendBlockerError) -> Self {
            Self::from(*wire)
        }
    }

    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ActivityGovernorAcquireUnmonitoredWakeLeaseRequest {
        pub name: ::std::string::String,
    }

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

                } = out_;
            }

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

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

            Ok(())
        }
    }

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

                } = out_;
            }

            ::fidl_next::Encode::encode(&self.name, encoder_, name, 64)?;

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

            Ok(())
        }
    }

    unsafe impl<___E>
        ::fidl_next::EncodeOption<
            ::fidl_next::wire::Box<
                'static,
                crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'static>,
            >,
            ___E,
        > for ActivityGovernorAcquireUnmonitoredWakeLeaseRequest
    where
        ___E: ::fidl_next::Encoder + ?Sized,
        ActivityGovernorAcquireUnmonitoredWakeLeaseRequest: ::fidl_next::Encode<
                crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'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::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'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(())
        }
    }

    unsafe impl<'a, ___E>
        ::fidl_next::EncodeOption<
            ::fidl_next::wire::Box<
                'static,
                crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'static>,
            >,
            ___E,
        > for &'a ActivityGovernorAcquireUnmonitoredWakeLeaseRequest
    where
        ___E: ::fidl_next::Encoder + ?Sized,
        &'a ActivityGovernorAcquireUnmonitoredWakeLeaseRequest: ::fidl_next::Encode<
                crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'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::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'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::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'de>>
        for ActivityGovernorAcquireUnmonitoredWakeLeaseRequest
    {
        #[inline]
        fn from_wire(
            wire: crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'de>,
        ) -> Self {
            Self { name: ::fidl_next::FromWire::from_wire(wire.name) }
        }
    }

    impl<'de>
        ::fidl_next::FromWireRef<
            crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'de>,
        > for ActivityGovernorAcquireUnmonitoredWakeLeaseRequest
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'de>,
        ) -> Self {
            Self { name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name) }
        }
    }

    pub type ActivityGovernorAcquireWakeLeaseWithTokenResponse = ();

    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ActivityGovernorTakeApplicationActivityLeaseRequest {
        pub name: ::std::string::String,
    }

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

                } = out_;
            }

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

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

            Ok(())
        }
    }

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

                } = out_;
            }

            ::fidl_next::Encode::encode(&self.name, encoder_, name, 64)?;

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

            Ok(())
        }
    }

    unsafe impl<___E>
        ::fidl_next::EncodeOption<
            ::fidl_next::wire::Box<
                'static,
                crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'static>,
            >,
            ___E,
        > for ActivityGovernorTakeApplicationActivityLeaseRequest
    where
        ___E: ::fidl_next::Encoder + ?Sized,
        ActivityGovernorTakeApplicationActivityLeaseRequest: ::fidl_next::Encode<
                crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'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::ActivityGovernorTakeApplicationActivityLeaseRequest<'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(())
        }
    }

    unsafe impl<'a, ___E>
        ::fidl_next::EncodeOption<
            ::fidl_next::wire::Box<
                'static,
                crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'static>,
            >,
            ___E,
        > for &'a ActivityGovernorTakeApplicationActivityLeaseRequest
    where
        ___E: ::fidl_next::Encoder + ?Sized,
        &'a ActivityGovernorTakeApplicationActivityLeaseRequest: ::fidl_next::Encode<
                crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'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::ActivityGovernorTakeApplicationActivityLeaseRequest<'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::ActivityGovernorTakeApplicationActivityLeaseRequest<'de>>
        for ActivityGovernorTakeApplicationActivityLeaseRequest
    {
        #[inline]
        fn from_wire(
            wire: crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'de>,
        ) -> Self {
            Self { name: ::fidl_next::FromWire::from_wire(wire.name) }
        }
    }

    impl<'de>
        ::fidl_next::FromWireRef<
            crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'de>,
        > for ActivityGovernorTakeApplicationActivityLeaseRequest
    {
        #[inline]
        fn from_wire_ref(
            wire: &crate::wire::ActivityGovernorTakeApplicationActivityLeaseRequest<'de>,
        ) -> Self {
            Self { name: ::fidl_next::FromWireRef::from_wire_ref(&wire.name) }
        }
    }

    #[doc = " Error codes for responses from `AddExecutionStateDependency` in\n [`fuchsia.power.system/CpuElementManager`].\n"]
    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    #[repr(u32)]
    pub enum AddExecutionStateDependencyError {
        InvalidArgs = 1,
        BadState = 2,
        UnknownOrdinal_(u32) = 3,
    }
    impl ::std::convert::From<u32> for AddExecutionStateDependencyError {
        fn from(value: u32) -> Self {
            match value {
                1 => Self::InvalidArgs,
                2 => Self::BadState,

                _ => Self::UnknownOrdinal_(value),
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::AddExecutionStateDependencyError, ___E>
        for AddExecutionStateDependencyError
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::AddExecutionStateDependencyError>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::Encode::encode(&self, encoder, out, ())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::AddExecutionStateDependencyError, ___E>
        for &'a AddExecutionStateDependencyError
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::AddExecutionStateDependencyError>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::AddExecutionStateDependencyError { value } = out);
            let _ = value.write(::fidl_next::wire::Uint32::from(match *self {
                AddExecutionStateDependencyError::InvalidArgs => 1,

                AddExecutionStateDependencyError::BadState => 2,

                AddExecutionStateDependencyError::UnknownOrdinal_(value) => value,
            }));

            Ok(())
        }
    }

    impl ::core::convert::From<crate::wire::AddExecutionStateDependencyError>
        for AddExecutionStateDependencyError
    {
        fn from(wire: crate::wire::AddExecutionStateDependencyError) -> Self {
            match u32::from(wire.value) {
                1 => Self::InvalidArgs,

                2 => Self::BadState,

                value => Self::UnknownOrdinal_(value),
            }
        }
    }

    impl ::fidl_next::FromWire<crate::wire::AddExecutionStateDependencyError>
        for AddExecutionStateDependencyError
    {
        #[inline]
        fn from_wire(wire: crate::wire::AddExecutionStateDependencyError) -> Self {
            Self::from(wire)
        }
    }

    impl ::fidl_next::FromWireRef<crate::wire::AddExecutionStateDependencyError>
        for AddExecutionStateDependencyError
    {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::AddExecutionStateDependencyError) -> Self {
            Self::from(*wire)
        }
    }

    #[doc = " Application activity power levels\n\n Elements that need to keep the system from suspending should take an assertive\n dependency on `ApplicationActivityLevel::ACTIVE`. When these components are\n performing work, they should request a lease to ensure the system remains\n active, and drop the lease when they are done.\n"]
    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    #[repr(u8)]
    pub enum ApplicationActivityLevel {
        Inactive = 0,
        Active = 1,
        UnknownOrdinal_(u8) = 2,
    }
    impl ::std::convert::From<u8> for ApplicationActivityLevel {
        fn from(value: u8) -> Self {
            match value {
                0 => Self::Inactive,
                1 => Self::Active,

                _ => Self::UnknownOrdinal_(value),
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ApplicationActivityLevel, ___E>
        for ApplicationActivityLevel
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ApplicationActivityLevel>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::Encode::encode(&self, encoder, out, ())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ApplicationActivityLevel, ___E>
        for &'a ApplicationActivityLevel
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ApplicationActivityLevel>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ApplicationActivityLevel { value } = out);
            let _ = value.write(u8::from(match *self {
                ApplicationActivityLevel::Inactive => 0,

                ApplicationActivityLevel::Active => 1,

                ApplicationActivityLevel::UnknownOrdinal_(value) => value,
            }));

            Ok(())
        }
    }

    impl ::core::convert::From<crate::wire::ApplicationActivityLevel> for ApplicationActivityLevel {
        fn from(wire: crate::wire::ApplicationActivityLevel) -> Self {
            match u8::from(wire.value) {
                0 => Self::Inactive,

                1 => Self::Active,

                value => Self::UnknownOrdinal_(value),
            }
        }
    }

    impl ::fidl_next::FromWire<crate::wire::ApplicationActivityLevel> for ApplicationActivityLevel {
        #[inline]
        fn from_wire(wire: crate::wire::ApplicationActivityLevel) -> Self {
            Self::from(wire)
        }
    }

    impl ::fidl_next::FromWireRef<crate::wire::ApplicationActivityLevel> for ApplicationActivityLevel {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::ApplicationActivityLevel) -> Self {
            Self::from(*wire)
        }
    }

    pub type BootControlSetBootCompleteResponse = ();

    pub type CpuElementManagerAddExecutionStateDependencyResponse = ();

    #[doc = " CPU power levels\n\n Elements should take an assertive dependency on `CpuLevel::ACTIVE`\n to ensure that the element will be suspended before the CPU suspends.\n"]
    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    #[repr(u8)]
    pub enum CpuLevel {
        Inactive = 0,
        Active = 1,
        UnknownOrdinal_(u8) = 2,
    }
    impl ::std::convert::From<u8> for CpuLevel {
        fn from(value: u8) -> Self {
            match value {
                0 => Self::Inactive,
                1 => Self::Active,

                _ => Self::UnknownOrdinal_(value),
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::CpuLevel, ___E> for CpuLevel
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::CpuLevel>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::Encode::encode(&self, encoder, out, ())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::CpuLevel, ___E> for &'a CpuLevel
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::CpuLevel>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::CpuLevel { value } = out);
            let _ = value.write(u8::from(match *self {
                CpuLevel::Inactive => 0,

                CpuLevel::Active => 1,

                CpuLevel::UnknownOrdinal_(value) => value,
            }));

            Ok(())
        }
    }

    impl ::core::convert::From<crate::wire::CpuLevel> for CpuLevel {
        fn from(wire: crate::wire::CpuLevel) -> Self {
            match u8::from(wire.value) {
                0 => Self::Inactive,

                1 => Self::Active,

                value => Self::UnknownOrdinal_(value),
            }
        }
    }

    impl ::fidl_next::FromWire<crate::wire::CpuLevel> for CpuLevel {
        #[inline]
        fn from_wire(wire: crate::wire::CpuLevel) -> Self {
            Self::from(wire)
        }
    }

    impl ::fidl_next::FromWireRef<crate::wire::CpuLevel> for CpuLevel {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::CpuLevel) -> Self {
            Self::from(*wire)
        }
    }

    #[doc = " Execution state power levels\n\n Elements should take an opportunistic dependency on `ExecutionStateLevel::ACTIVE`\n to ensure that the element will be suspended when the rest of the system\n suspends.\n\n Drivers can take an opportunistic dependency on either\n `ExecutionStateLevel::SUSPENDING` or `ExecutionStateLevel::ACTIVE` and\n request a persistent lease on this state to ensure that their element\'s\n power level is always activated when the system comes out of a suspend\n state.\n"]
    #[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    #[repr(u8)]
    pub enum ExecutionStateLevel {
        Inactive = 0,
        Suspending = 1,
        Active = 2,
        UnknownOrdinal_(u8) = 3,
    }
    impl ::std::convert::From<u8> for ExecutionStateLevel {
        fn from(value: u8) -> Self {
            match value {
                0 => Self::Inactive,
                1 => Self::Suspending,
                2 => Self::Active,

                _ => Self::UnknownOrdinal_(value),
            }
        }
    }

    unsafe impl<___E> ::fidl_next::Encode<crate::wire::ExecutionStateLevel, ___E>
        for ExecutionStateLevel
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ExecutionStateLevel>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::Encode::encode(&self, encoder, out, ())
        }
    }

    unsafe impl<'a, ___E> ::fidl_next::Encode<crate::wire::ExecutionStateLevel, ___E>
        for &'a ExecutionStateLevel
    where
        ___E: ?Sized,
    {
        #[inline]
        fn encode(
            self,
            encoder: &mut ___E,
            out: &mut ::core::mem::MaybeUninit<crate::wire::ExecutionStateLevel>,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
            ::fidl_next::munge!(let crate::wire::ExecutionStateLevel { value } = out);
            let _ = value.write(u8::from(match *self {
                ExecutionStateLevel::Inactive => 0,

                ExecutionStateLevel::Suspending => 1,

                ExecutionStateLevel::Active => 2,

                ExecutionStateLevel::UnknownOrdinal_(value) => value,
            }));

            Ok(())
        }
    }

    impl ::core::convert::From<crate::wire::ExecutionStateLevel> for ExecutionStateLevel {
        fn from(wire: crate::wire::ExecutionStateLevel) -> Self {
            match u8::from(wire.value) {
                0 => Self::Inactive,

                1 => Self::Suspending,

                2 => Self::Active,

                value => Self::UnknownOrdinal_(value),
            }
        }
    }

    impl ::fidl_next::FromWire<crate::wire::ExecutionStateLevel> for ExecutionStateLevel {
        #[inline]
        fn from_wire(wire: crate::wire::ExecutionStateLevel) -> Self {
            Self::from(wire)
        }
    }

    impl ::fidl_next::FromWireRef<crate::wire::ExecutionStateLevel> for ExecutionStateLevel {
        #[inline]
        fn from_wire_ref(wire: &crate::wire::ExecutionStateLevel) -> Self {
            Self::from(*wire)
        }
    }

    pub type SuspendBlockerBeforeSuspendResponse = ();

    pub type SuspendBlockerAfterResumeResponse = ();
}

pub mod wire {

    /// The wire type corresponding to [`AcquireWakeLeaseError`].
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct AcquireWakeLeaseError {
        pub(crate) value: ::fidl_next::wire::Uint32,
    }

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

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

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

        #[inline]
        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
            // Wire enums have no padding
        }
    }

    impl AcquireWakeLeaseError {
        pub const INTERNAL: AcquireWakeLeaseError =
            AcquireWakeLeaseError { value: ::fidl_next::wire::Uint32(1) };

        pub const INVALID_NAME: AcquireWakeLeaseError =
            AcquireWakeLeaseError { value: ::fidl_next::wire::Uint32(2) };
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for AcquireWakeLeaseError
    where
        ___D: ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            _: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            Ok(())
        }
    }

    impl ::core::convert::From<crate::natural::AcquireWakeLeaseError> for AcquireWakeLeaseError {
        fn from(natural: crate::natural::AcquireWakeLeaseError) -> Self {
            match natural {
                crate::natural::AcquireWakeLeaseError::Internal => AcquireWakeLeaseError::INTERNAL,

                crate::natural::AcquireWakeLeaseError::InvalidName => {
                    AcquireWakeLeaseError::INVALID_NAME
                }

                crate::natural::AcquireWakeLeaseError::UnknownOrdinal_(value) => {
                    AcquireWakeLeaseError { value: ::fidl_next::wire::Uint32::from(value) }
                }
            }
        }
    }

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

    /// The wire type corresponding to [`ActivityGovernorAcquireWakeLeaseRequest`].
    #[derive(Debug)]
    #[repr(C)]
    pub struct ActivityGovernorAcquireWakeLeaseRequest<'de> {
        pub name: ::fidl_next::wire::String<'de>,
    }

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

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

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

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

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

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

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(name);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D> for ActivityGovernorAcquireWakeLeaseRequest<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {
                    mut name,

                } = slot_;
            }

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

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

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

            Ok(())
        }
    }

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

    /// The wire type corresponding to [`RegisterSuspendBlockerError`].
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct RegisterSuspendBlockerError {
        pub(crate) value: ::fidl_next::wire::Uint32,
    }

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

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

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

        #[inline]
        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
            // Wire enums have no padding
        }
    }

    impl RegisterSuspendBlockerError {
        pub const INTERNAL: RegisterSuspendBlockerError =
            RegisterSuspendBlockerError { value: ::fidl_next::wire::Uint32(1) };

        pub const INVALID_ARGS: RegisterSuspendBlockerError =
            RegisterSuspendBlockerError { value: ::fidl_next::wire::Uint32(2) };
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for RegisterSuspendBlockerError
    where
        ___D: ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            _: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            Ok(())
        }
    }

    impl ::core::convert::From<crate::natural::RegisterSuspendBlockerError>
        for RegisterSuspendBlockerError
    {
        fn from(natural: crate::natural::RegisterSuspendBlockerError) -> Self {
            match natural {
                crate::natural::RegisterSuspendBlockerError::Internal => {
                    RegisterSuspendBlockerError::INTERNAL
                }

                crate::natural::RegisterSuspendBlockerError::InvalidArgs => {
                    RegisterSuspendBlockerError::INVALID_ARGS
                }

                crate::natural::RegisterSuspendBlockerError::UnknownOrdinal_(value) => {
                    RegisterSuspendBlockerError { value: ::fidl_next::wire::Uint32::from(value) }
                }
            }
        }
    }

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

    /// The wire type corresponding to [`ActivityGovernorAcquireUnmonitoredWakeLeaseRequest`].
    #[derive(Debug)]
    #[repr(C)]
    pub struct ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'de> {
        pub name: ::fidl_next::wire::String<'de>,
    }

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

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

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

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

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

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

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(name);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
        for ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {
                    mut name,

                } = slot_;
            }

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

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

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

            Ok(())
        }
    }

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

    /// The wire type corresponding to [`ActivityGovernorAcquireWakeLeaseWithTokenResponse`].
    pub type ActivityGovernorAcquireWakeLeaseWithTokenResponse = ::fidl_next::wire::Unit;

    /// The wire type corresponding to [`ActivityGovernorTakeApplicationActivityLeaseRequest`].
    #[derive(Debug)]
    #[repr(C)]
    pub struct ActivityGovernorTakeApplicationActivityLeaseRequest<'de> {
        pub name: ::fidl_next::wire::String<'de>,
    }

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

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

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

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

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

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

                } = &mut *out_;
            }

            ::fidl_next::Wire::zero_padding(name);
        }
    }

    unsafe impl<'de, ___D> ::fidl_next::Decode<___D>
        for ActivityGovernorTakeApplicationActivityLeaseRequest<'de>
    where
        ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
        ___D: ::fidl_next::Decoder<'de>,
    {
        fn decode(
            slot_: ::fidl_next::Slot<'_, Self>,
            decoder_: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            ::fidl_next::munge! {
                let Self {
                    mut name,

                } = slot_;
            }

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

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

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

            Ok(())
        }
    }

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

    /// The wire type corresponding to [`AddExecutionStateDependencyError`].
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct AddExecutionStateDependencyError {
        pub(crate) value: ::fidl_next::wire::Uint32,
    }

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

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

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

        #[inline]
        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
            // Wire enums have no padding
        }
    }

    impl AddExecutionStateDependencyError {
        pub const INVALID_ARGS: AddExecutionStateDependencyError =
            AddExecutionStateDependencyError { value: ::fidl_next::wire::Uint32(1) };

        pub const BAD_STATE: AddExecutionStateDependencyError =
            AddExecutionStateDependencyError { value: ::fidl_next::wire::Uint32(2) };
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for AddExecutionStateDependencyError
    where
        ___D: ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            _: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            Ok(())
        }
    }

    impl ::core::convert::From<crate::natural::AddExecutionStateDependencyError>
        for AddExecutionStateDependencyError
    {
        fn from(natural: crate::natural::AddExecutionStateDependencyError) -> Self {
            match natural {
                crate::natural::AddExecutionStateDependencyError::InvalidArgs => {
                    AddExecutionStateDependencyError::INVALID_ARGS
                }

                crate::natural::AddExecutionStateDependencyError::BadState => {
                    AddExecutionStateDependencyError::BAD_STATE
                }

                crate::natural::AddExecutionStateDependencyError::UnknownOrdinal_(value) => {
                    AddExecutionStateDependencyError {
                        value: ::fidl_next::wire::Uint32::from(value),
                    }
                }
            }
        }
    }

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

    /// The wire type corresponding to [`ApplicationActivityLevel`].
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct ApplicationActivityLevel {
        pub(crate) value: u8,
    }

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

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

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

        #[inline]
        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
            // Wire enums have no padding
        }
    }

    impl ApplicationActivityLevel {
        pub const INACTIVE: ApplicationActivityLevel = ApplicationActivityLevel { value: 0 };

        pub const ACTIVE: ApplicationActivityLevel = ApplicationActivityLevel { value: 1 };
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for ApplicationActivityLevel
    where
        ___D: ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            _: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            Ok(())
        }
    }

    impl ::core::convert::From<crate::natural::ApplicationActivityLevel> for ApplicationActivityLevel {
        fn from(natural: crate::natural::ApplicationActivityLevel) -> Self {
            match natural {
                crate::natural::ApplicationActivityLevel::Inactive => {
                    ApplicationActivityLevel::INACTIVE
                }

                crate::natural::ApplicationActivityLevel::Active => {
                    ApplicationActivityLevel::ACTIVE
                }

                crate::natural::ApplicationActivityLevel::UnknownOrdinal_(value) => {
                    ApplicationActivityLevel { value: u8::from(value) }
                }
            }
        }
    }

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

    /// The wire type corresponding to [`BootControlSetBootCompleteResponse`].
    pub type BootControlSetBootCompleteResponse = ::fidl_next::wire::Unit;

    /// The wire type corresponding to [`CpuElementManagerAddExecutionStateDependencyResponse`].
    pub type CpuElementManagerAddExecutionStateDependencyResponse = ::fidl_next::wire::Unit;

    /// The wire type corresponding to [`CpuLevel`].
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct CpuLevel {
        pub(crate) value: u8,
    }

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

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

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

        #[inline]
        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
            // Wire enums have no padding
        }
    }

    impl CpuLevel {
        pub const INACTIVE: CpuLevel = CpuLevel { value: 0 };

        pub const ACTIVE: CpuLevel = CpuLevel { value: 1 };
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for CpuLevel
    where
        ___D: ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            _: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            Ok(())
        }
    }

    impl ::core::convert::From<crate::natural::CpuLevel> for CpuLevel {
        fn from(natural: crate::natural::CpuLevel) -> Self {
            match natural {
                crate::natural::CpuLevel::Inactive => CpuLevel::INACTIVE,

                crate::natural::CpuLevel::Active => CpuLevel::ACTIVE,

                crate::natural::CpuLevel::UnknownOrdinal_(value) => {
                    CpuLevel { value: u8::from(value) }
                }
            }
        }
    }

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

    /// The wire type corresponding to [`ExecutionStateLevel`].
    #[derive(Clone, Copy, Debug, PartialEq, Eq)]
    #[repr(transparent)]
    pub struct ExecutionStateLevel {
        pub(crate) value: u8,
    }

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

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

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

        #[inline]
        fn zero_padding(_: &mut ::core::mem::MaybeUninit<Self>) {
            // Wire enums have no padding
        }
    }

    impl ExecutionStateLevel {
        pub const INACTIVE: ExecutionStateLevel = ExecutionStateLevel { value: 0 };

        pub const SUSPENDING: ExecutionStateLevel = ExecutionStateLevel { value: 1 };

        pub const ACTIVE: ExecutionStateLevel = ExecutionStateLevel { value: 2 };
    }

    unsafe impl<___D> ::fidl_next::Decode<___D> for ExecutionStateLevel
    where
        ___D: ?Sized,
    {
        fn decode(
            slot: ::fidl_next::Slot<'_, Self>,
            _: &mut ___D,
            _: (),
        ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
            Ok(())
        }
    }

    impl ::core::convert::From<crate::natural::ExecutionStateLevel> for ExecutionStateLevel {
        fn from(natural: crate::natural::ExecutionStateLevel) -> Self {
            match natural {
                crate::natural::ExecutionStateLevel::Inactive => ExecutionStateLevel::INACTIVE,

                crate::natural::ExecutionStateLevel::Suspending => ExecutionStateLevel::SUSPENDING,

                crate::natural::ExecutionStateLevel::Active => ExecutionStateLevel::ACTIVE,

                crate::natural::ExecutionStateLevel::UnknownOrdinal_(value) => {
                    ExecutionStateLevel { value: u8::from(value) }
                }
            }
        }
    }

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

    /// The wire type corresponding to [`SuspendBlockerBeforeSuspendResponse`].
    pub type SuspendBlockerBeforeSuspendResponse = ::fidl_next::wire::Unit;

    /// The wire type corresponding to [`SuspendBlockerAfterResumeResponse`].
    pub type SuspendBlockerAfterResumeResponse = ::fidl_next::wire::Unit;
}

pub mod wire_optional {}

pub mod generic {

    /// The generic type corresponding to [`ActivityGovernorAcquireWakeLeaseRequest`].
    pub struct ActivityGovernorAcquireWakeLeaseRequest<T0> {
        pub name: T0,
    }

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

                } = out_;
            }

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

            Ok(())
        }
    }

    /// The generic type corresponding to [`ActivityGovernorAcquireUnmonitoredWakeLeaseRequest`].
    pub struct ActivityGovernorAcquireUnmonitoredWakeLeaseRequest<T0> {
        pub name: T0,
    }

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

                } = out_;
            }

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

            Ok(())
        }
    }

    /// The generic type corresponding to [`ActivityGovernorAcquireWakeLeaseWithTokenResponse`].
    pub type ActivityGovernorAcquireWakeLeaseWithTokenResponse = ();

    /// The generic type corresponding to [`ActivityGovernorTakeApplicationActivityLeaseRequest`].
    pub struct ActivityGovernorTakeApplicationActivityLeaseRequest<T0> {
        pub name: T0,
    }

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

                } = out_;
            }

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

            Ok(())
        }
    }

    /// The generic type corresponding to [`BootControlSetBootCompleteResponse`].
    pub type BootControlSetBootCompleteResponse = ();

    /// The generic type corresponding to [`CpuElementManagerAddExecutionStateDependencyResponse`].
    pub type CpuElementManagerAddExecutionStateDependencyResponse = ();

    /// The generic type corresponding to [`SuspendBlockerBeforeSuspendResponse`].
    pub type SuspendBlockerBeforeSuspendResponse = ();

    /// The generic type corresponding to [`SuspendBlockerAfterResumeResponse`].
    pub type SuspendBlockerAfterResumeResponse = ();
}

pub use self::natural::*;

pub const MAX_ELEMENT_NAME_LEN: u8 = 64 as u8;

/// The type corresponding to the BootControl protocol.
#[doc = " A service that processes notification about the system boot state.\n"]
#[derive(PartialEq, Debug)]
pub struct BootControl;

impl ::fidl_next::Discoverable for BootControl {
    const PROTOCOL_NAME: &'static str = "fuchsia.power.system.BootControl";
}

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

pub mod boot_control {
    pub mod prelude {
        pub use crate::{
            BootControl, BootControlClientHandler, BootControlLocalClientHandler,
            BootControlLocalServerHandler, BootControlServerHandler, boot_control,
        };

        pub use crate::natural::BootControlSetBootCompleteResponse;
    }

    pub struct SetBootComplete;

    impl ::fidl_next::Method for SetBootComplete {
        const ORDINAL: u64 = 4367259243539899061;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::BootControl;

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

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

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

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

    mod ___detail {
        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::BootControl
        where
            ___T: ::fidl_next::Transport,
        {
            type Client = BootControlClient<___T>;
            type Server = BootControlServer<___T>;
        }

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

        impl<___T> BootControlClient<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            #[doc = " Notify the SAG that the system has booted. SAG will not suspend the\n hardware platform until this method is called at least once per boot.\n"]
            pub fn set_boot_complete(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::SetBootComplete, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(
                    self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
                        4367259243539899061,
                        <super::SetBootComplete as ::fidl_next::Method>::FLEXIBILITY,
                        (),
                    ),
                )
            }
        }

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

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

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

/// A client handler for the BootControl protocol.
///
/// See [`BootControl`] for more details.
pub trait BootControlLocalClientHandler<
    #[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 BootControl
where
    ___H: BootControlLocalClientHandler<___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 BootControlServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
)]

/// A server handler for the BootControl protocol.
///
/// See [`BootControl`] for more details.
pub trait BootControlLocalServerHandler<
    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
>
{
    #[doc = " Notify the SAG that the system has booted. SAG will not suspend the\n hardware platform until this method is called at least once per boot.\n"]
    fn set_boot_complete(
        &mut self,

        responder: ::fidl_next::Responder<boot_control::SetBootComplete, ___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 BootControl
where
    ___H: BootControlLocalServerHandler<___T>,
    ___T: ::fidl_next::Transport,
{
    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 {
            4367259243539899061 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.set_boot_complete(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 BootControl protocol.
///
/// See [`BootControl`] for more details.
pub trait BootControlClientHandler<
    #[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 BootControl
where
    ___H: BootControlClientHandler<___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 BootControl protocol.
///
/// See [`BootControl`] for more details.
pub trait BootControlServerHandler<
    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
>
{
    #[doc = " Notify the SAG that the system has booted. SAG will not suspend the\n hardware platform until this method is called at least once per boot.\n"]
    fn set_boot_complete(
        &mut self,

        responder: ::fidl_next::Responder<boot_control::SetBootComplete, ___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 BootControl
where
    ___H: BootControlServerHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
{
    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 {
            4367259243539899061 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                handler.set_boot_complete(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> BootControlClientHandler<___T> for ::fidl_next::IgnoreEvents
where
    ___T: ::fidl_next::Transport,
{
    async fn on_unknown_interaction(&mut self, _: u64) {}
}

impl<___H, ___T> BootControlLocalClientHandler<___T> for ::fidl_next::Local<___H>
where
    ___H: BootControlClientHandler<___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> BootControlLocalServerHandler<___T> for ::fidl_next::Local<___H>
where
    ___H: BootControlServerHandler<___T>,
    ___T: ::fidl_next::Transport,
{
    async fn set_boot_complete(
        &mut self,

        responder: ::fidl_next::Responder<boot_control::SetBootComplete, ___T>,
    ) {
        ___H::set_boot_complete(&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 SuspendBlocker protocol.
#[doc = " An entity that blocks suspend until it handles transitions across hardware\n platform suspend and resume.\n"]
#[derive(PartialEq, Debug)]
pub struct SuspendBlocker;

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

pub mod suspend_blocker {
    pub mod prelude {
        pub use crate::{
            SuspendBlocker, SuspendBlockerClientHandler, SuspendBlockerLocalClientHandler,
            SuspendBlockerLocalServerHandler, SuspendBlockerServerHandler, suspend_blocker,
        };

        pub use crate::natural::SuspendBlockerAfterResumeResponse;

        pub use crate::natural::SuspendBlockerBeforeSuspendResponse;
    }

    pub struct BeforeSuspend;

    impl ::fidl_next::Method for BeforeSuspend {
        const ORDINAL: u64 = 7734531672310967680;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::SuspendBlocker;

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

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

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

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

    pub struct AfterResume;

    impl ::fidl_next::Method for AfterResume {
        const ORDINAL: u64 = 7652351326344392170;
        const FLEXIBILITY: ::fidl_next::protocol::Flexibility =
            ::fidl_next::protocol::Flexibility::Flexible;

        type Protocol = crate::SuspendBlocker;

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

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

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

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

    mod ___detail {
        unsafe impl<___T> ::fidl_next::HasConnectionHandles<___T> for crate::SuspendBlocker
        where
            ___T: ::fidl_next::Transport,
        {
            type Client = SuspendBlockerClient<___T>;
            type Server = SuspendBlockerServer<___T>;
        }

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

        impl<___T> SuspendBlockerClient<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            #[doc = " Called after system activity governor begins operations to suspend the\n hardware platform.\n\n The server is expected to respond once it has performed the operations\n it needs to prepare itself for suspend, if any. All dependencies of\n `ExecutionStateLevel::SUSPENDING` are guaranteed to be satisified for\n the duration of this call and may be revoked once the server replies.\n\n Operations to suspend the hardware platform may vary between different\n hardware platforms and product configurations. At a minimum, the client\n and server MUST assume that general code execution continues\n until a reply to this call is received by the client. If the\n SuspendBlocker wants to preempt suspend operations, it MUST call\n `ActivityGovernor.AcquireWakeLease` before replying to this call.\n\n ExecutionState will be at its SUSPENDING level for the duration of this\n call. Consequently, a SuspendBlocker MUST NOT call\n `ActivityGovernor.TakeApplicationActivityLease` nor perform any other\n  action that blocks on Execution State reaching a level other than\n INACTIVE. Doing so will result in a deadlock. (However, AcquireWakeLease\n does _not_ block in this way and is safe to call.)\n"]
            pub fn before_suspend(
                &self,
            ) -> ::fidl_next::TwoWayFuture<'_, super::BeforeSuspend, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(
                    self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
                        7734531672310967680,
                        <super::BeforeSuspend as ::fidl_next::Method>::FLEXIBILITY,
                        (),
                    ),
                )
            }

            #[doc = " Called after system activity governor is aware that the hardware\n platform has resumed.\n\n For the duration of this call, ExecutionState is at level INACTIVE,\n but all dependencies of `ExecutionStateLevel::SUSPENDING` are guaranteed\n be satisified.\n\n Consequently, a SuspendBlocker MUST NOT call\n `ActivityGovernor.TakeApplicationActivityLease` nor perform any other\n  action that blocks on Execution State reaching a level other than\n INACTIVE. Doing so will result in a deadlock. (However, AcquireWakeLease\n does _not_ block in this way and is safe to call.)\n"]
            pub fn after_resume(&self) -> ::fidl_next::TwoWayFuture<'_, super::AfterResume, ___T> {
                ::fidl_next::TwoWayFuture::from_untyped(
                    self.client.send_two_way::<::fidl_next::wire::EmptyMessageBody>(
                        7652351326344392170,
                        <super::AfterResume as ::fidl_next::Method>::FLEXIBILITY,
                        (),
                    ),
                )
            }
        }

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

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

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

/// A client handler for the SuspendBlocker protocol.
///
/// See [`SuspendBlocker`] for more details.
pub trait SuspendBlockerLocalClientHandler<
    #[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 SuspendBlocker
where
    ___H: SuspendBlockerLocalClientHandler<___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 SuspendBlockerServerHandler trait, use `spawn_as_local` or the `Local` adapter type"
)]

/// A server handler for the SuspendBlocker protocol.
///
/// See [`SuspendBlocker`] for more details.
pub trait SuspendBlockerLocalServerHandler<
    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
>
{
    #[doc = " Called after system activity governor begins operations to suspend the\n hardware platform.\n\n The server is expected to respond once it has performed the operations\n it needs to prepare itself for suspend, if any. All dependencies of\n `ExecutionStateLevel::SUSPENDING` are guaranteed to be satisified for\n the duration of this call and may be revoked once the server replies.\n\n Operations to suspend the hardware platform may vary between different\n hardware platforms and product configurations. At a minimum, the client\n and server MUST assume that general code execution continues\n until a reply to this call is received by the client. If the\n SuspendBlocker wants to preempt suspend operations, it MUST call\n `ActivityGovernor.AcquireWakeLease` before replying to this call.\n\n ExecutionState will be at its SUSPENDING level for the duration of this\n call. Consequently, a SuspendBlocker MUST NOT call\n `ActivityGovernor.TakeApplicationActivityLease` nor perform any other\n  action that blocks on Execution State reaching a level other than\n INACTIVE. Doing so will result in a deadlock. (However, AcquireWakeLease\n does _not_ block in this way and is safe to call.)\n"]
    fn before_suspend(
        &mut self,

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

    #[doc = " Called after system activity governor is aware that the hardware\n platform has resumed.\n\n For the duration of this call, ExecutionState is at level INACTIVE,\n but all dependencies of `ExecutionStateLevel::SUSPENDING` are guaranteed\n be satisified.\n\n Consequently, a SuspendBlocker MUST NOT call\n `ActivityGovernor.TakeApplicationActivityLease` nor perform any other\n  action that blocks on Execution State reaching a level other than\n INACTIVE. Doing so will result in a deadlock. (However, AcquireWakeLease\n does _not_ block in this way and is safe to call.)\n"]
    fn after_resume(
        &mut self,

        responder: ::fidl_next::Responder<suspend_blocker::AfterResume, ___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 SuspendBlocker
where
    ___H: SuspendBlockerLocalServerHandler<___T>,
    ___T: ::fidl_next::Transport,
{
    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 {
            7734531672310967680 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

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

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

                handler.after_resume(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 SuspendBlocker protocol.
///
/// See [`SuspendBlocker`] for more details.
pub trait SuspendBlockerClientHandler<
    #[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 SuspendBlocker
where
    ___H: SuspendBlockerClientHandler<___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 SuspendBlocker protocol.
///
/// See [`SuspendBlocker`] for more details.
pub trait SuspendBlockerServerHandler<
    #[cfg(target_os = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
    #[cfg(not(target_os = "fuchsia"))] ___T: ::fidl_next::Transport,
>
{
    #[doc = " Called after system activity governor begins operations to suspend the\n hardware platform.\n\n The server is expected to respond once it has performed the operations\n it needs to prepare itself for suspend, if any. All dependencies of\n `ExecutionStateLevel::SUSPENDING` are guaranteed to be satisified for\n the duration of this call and may be revoked once the server replies.\n\n Operations to suspend the hardware platform may vary between different\n hardware platforms and product configurations. At a minimum, the client\n and server MUST assume that general code execution continues\n until a reply to this call is received by the client. If the\n SuspendBlocker wants to preempt suspend operations, it MUST call\n `ActivityGovernor.AcquireWakeLease` before replying to this call.\n\n ExecutionState will be at its SUSPENDING level for the duration of this\n call. Consequently, a SuspendBlocker MUST NOT call\n `ActivityGovernor.TakeApplicationActivityLease` nor perform any other\n  action that blocks on Execution State reaching a level other than\n INACTIVE. Doing so will result in a deadlock. (However, AcquireWakeLease\n does _not_ block in this way and is safe to call.)\n"]
    fn before_suspend(
        &mut self,

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

    #[doc = " Called after system activity governor is aware that the hardware\n platform has resumed.\n\n For the duration of this call, ExecutionState is at level INACTIVE,\n but all dependencies of `ExecutionStateLevel::SUSPENDING` are guaranteed\n be satisified.\n\n Consequently, a SuspendBlocker MUST NOT call\n `ActivityGovernor.TakeApplicationActivityLease` nor perform any other\n  action that blocks on Execution State reaching a level other than\n INACTIVE. Doing so will result in a deadlock. (However, AcquireWakeLease\n does _not_ block in this way and is safe to call.)\n"]
    fn after_resume(
        &mut self,

        responder: ::fidl_next::Responder<suspend_blocker::AfterResume, ___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 SuspendBlocker
where
    ___H: SuspendBlockerServerHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
{
    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 {
            7734531672310967680 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

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

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

                handler.after_resume(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> SuspendBlockerClientHandler<___T> for ::fidl_next::IgnoreEvents
where
    ___T: ::fidl_next::Transport,
{
    async fn on_unknown_interaction(&mut self, _: u64) {}
}

impl<___H, ___T> SuspendBlockerLocalClientHandler<___T> for ::fidl_next::Local<___H>
where
    ___H: SuspendBlockerClientHandler<___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> SuspendBlockerLocalServerHandler<___T> for ::fidl_next::Local<___H>
where
    ___H: SuspendBlockerServerHandler<___T>,
    ___T: ::fidl_next::Transport,
{
    async fn before_suspend(
        &mut self,

        responder: ::fidl_next::Responder<suspend_blocker::BeforeSuspend, ___T>,
    ) {
        ___H::before_suspend(&mut self.0, responder).await
    }

    async fn after_resume(
        &mut self,

        responder: ::fidl_next::Responder<suspend_blocker::AfterResume, ___T>,
    ) {
        ___H::after_resume(&mut self.0, responder).await
    }

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