fidl_next_fuchsia_examples_calculator/

fidl_next_fuchsia_examples_calculator.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)]

#[derive(Clone, Debug)]
#[repr(C)]
pub struct CalculatorAddRequest {
    pub a: f64,

    pub b: f64,
}

impl ::fidl_next::Encodable for CalculatorAddRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireCalculatorAddRequest> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <f64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <f64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireCalculatorAddRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for CalculatorAddRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                a,
                b,

            } = out;
        }

        ::fidl_next::Encode::encode(self.a, encoder, a)?;

        ::fidl_next::Encode::encode(self.b, encoder, b)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CalculatorAddRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                a,
                b,

            } = out;
        }

        ::fidl_next::EncodeRef::encode_ref(&self.a, encoder, a)?;

        ::fidl_next::EncodeRef::encode_ref(&self.b, encoder, b)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for CalculatorAddRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireCalculatorAddRequest>;
}

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CalculatorAddRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    CalculatorAddRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireCalculatorAddRequest> for CalculatorAddRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireCalculatorAddRequest, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <f64 as ::fidl_next::FromWire<::fidl_next::WireF64>>::COPY_OPTIMIZATION
                .is_enabled()
                && <f64 as ::fidl_next::FromWire<::fidl_next::WireF64>>::COPY_OPTIMIZATION
                    .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireCalculatorAddRequest) -> Self {
        Self {
            a: ::fidl_next::FromWire::from_wire(wire.a),

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

impl ::fidl_next::FromWireRef<WireCalculatorAddRequest> for CalculatorAddRequest {
    #[inline]
    fn from_wire_ref(wire: &WireCalculatorAddRequest) -> Self {
        Self {
            a: ::fidl_next::FromWireRef::from_wire_ref(&wire.a),

            b: ::fidl_next::FromWireRef::from_wire_ref(&wire.b),
        }
    }
}

/// The wire type corresponding to [`CalculatorAddRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireCalculatorAddRequest {
    pub a: ::fidl_next::WireF64,

    pub b: ::fidl_next::WireF64,
}

unsafe impl ::fidl_next::Wire for WireCalculatorAddRequest {
    type Decoded<'de> = WireCalculatorAddRequest;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCalculatorAddRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut a,
                mut b,

            } = slot;
        }

        ::fidl_next::Decode::decode(a.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(b.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct CalculatorAddResponse {
    pub sum: f64,
}

impl ::fidl_next::Encodable for CalculatorAddResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireCalculatorAddResponse> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <f64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireCalculatorAddResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for CalculatorAddResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                sum,

            } = out;
        }

        ::fidl_next::Encode::encode(self.sum, encoder, sum)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CalculatorAddResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                sum,

            } = out;
        }

        ::fidl_next::EncodeRef::encode_ref(&self.sum, encoder, sum)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for CalculatorAddResponse {
    type EncodedOption = ::fidl_next::WireBox<'static, WireCalculatorAddResponse>;
}

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CalculatorAddResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    CalculatorAddResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireCalculatorAddResponse> for CalculatorAddResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireCalculatorAddResponse, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <f64 as ::fidl_next::FromWire<::fidl_next::WireF64>>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireCalculatorAddResponse) -> Self {
        Self { sum: ::fidl_next::FromWire::from_wire(wire.sum) }
    }
}

impl ::fidl_next::FromWireRef<WireCalculatorAddResponse> for CalculatorAddResponse {
    #[inline]
    fn from_wire_ref(wire: &WireCalculatorAddResponse) -> Self {
        Self { sum: ::fidl_next::FromWireRef::from_wire_ref(&wire.sum) }
    }
}

/// The wire type corresponding to [`CalculatorAddResponse`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireCalculatorAddResponse {
    pub sum: ::fidl_next::WireF64,
}

unsafe impl ::fidl_next::Wire for WireCalculatorAddResponse {
    type Decoded<'de> = WireCalculatorAddResponse;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCalculatorAddResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut sum,

            } = slot;
        }

        ::fidl_next::Decode::decode(sum.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct CalculatorSubtractRequest {
    pub a: f64,

    pub b: f64,
}

impl ::fidl_next::Encodable for CalculatorSubtractRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireCalculatorSubtractRequest> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <f64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <f64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireCalculatorSubtractRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for CalculatorSubtractRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                a,
                b,

            } = out;
        }

        ::fidl_next::Encode::encode(self.a, encoder, a)?;

        ::fidl_next::Encode::encode(self.b, encoder, b)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CalculatorSubtractRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                a,
                b,

            } = out;
        }

        ::fidl_next::EncodeRef::encode_ref(&self.a, encoder, a)?;

        ::fidl_next::EncodeRef::encode_ref(&self.b, encoder, b)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for CalculatorSubtractRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireCalculatorSubtractRequest>;
}

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CalculatorSubtractRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    CalculatorSubtractRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireCalculatorSubtractRequest> for CalculatorSubtractRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireCalculatorSubtractRequest, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <f64 as ::fidl_next::FromWire<::fidl_next::WireF64>>::COPY_OPTIMIZATION
                .is_enabled()
                && <f64 as ::fidl_next::FromWire<::fidl_next::WireF64>>::COPY_OPTIMIZATION
                    .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireCalculatorSubtractRequest) -> Self {
        Self {
            a: ::fidl_next::FromWire::from_wire(wire.a),

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

impl ::fidl_next::FromWireRef<WireCalculatorSubtractRequest> for CalculatorSubtractRequest {
    #[inline]
    fn from_wire_ref(wire: &WireCalculatorSubtractRequest) -> Self {
        Self {
            a: ::fidl_next::FromWireRef::from_wire_ref(&wire.a),

            b: ::fidl_next::FromWireRef::from_wire_ref(&wire.b),
        }
    }
}

/// The wire type corresponding to [`CalculatorSubtractRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireCalculatorSubtractRequest {
    pub a: ::fidl_next::WireF64,

    pub b: ::fidl_next::WireF64,
}

unsafe impl ::fidl_next::Wire for WireCalculatorSubtractRequest {
    type Decoded<'de> = WireCalculatorSubtractRequest;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCalculatorSubtractRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut a,
                mut b,

            } = slot;
        }

        ::fidl_next::Decode::decode(a.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(b.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct CalculatorSubtractResponse {
    pub difference: f64,
}

impl ::fidl_next::Encodable for CalculatorSubtractResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireCalculatorSubtractResponse> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <f64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireCalculatorSubtractResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for CalculatorSubtractResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                difference,

            } = out;
        }

        ::fidl_next::Encode::encode(self.difference, encoder, difference)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CalculatorSubtractResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                difference,

            } = out;
        }

        ::fidl_next::EncodeRef::encode_ref(&self.difference, encoder, difference)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for CalculatorSubtractResponse {
    type EncodedOption = ::fidl_next::WireBox<'static, WireCalculatorSubtractResponse>;
}

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CalculatorSubtractResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    CalculatorSubtractResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireCalculatorSubtractResponse> for CalculatorSubtractResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireCalculatorSubtractResponse, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <f64 as ::fidl_next::FromWire<::fidl_next::WireF64>>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireCalculatorSubtractResponse) -> Self {
        Self { difference: ::fidl_next::FromWire::from_wire(wire.difference) }
    }
}

impl ::fidl_next::FromWireRef<WireCalculatorSubtractResponse> for CalculatorSubtractResponse {
    #[inline]
    fn from_wire_ref(wire: &WireCalculatorSubtractResponse) -> Self {
        Self { difference: ::fidl_next::FromWireRef::from_wire_ref(&wire.difference) }
    }
}

/// The wire type corresponding to [`CalculatorSubtractResponse`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireCalculatorSubtractResponse {
    pub difference: ::fidl_next::WireF64,
}

unsafe impl ::fidl_next::Wire for WireCalculatorSubtractResponse {
    type Decoded<'de> = WireCalculatorSubtractResponse;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCalculatorSubtractResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut difference,

            } = slot;
        }

        ::fidl_next::Decode::decode(difference.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct CalculatorMultiplyRequest {
    pub a: f64,

    pub b: f64,
}

impl ::fidl_next::Encodable for CalculatorMultiplyRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireCalculatorMultiplyRequest> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <f64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <f64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireCalculatorMultiplyRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for CalculatorMultiplyRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                a,
                b,

            } = out;
        }

        ::fidl_next::Encode::encode(self.a, encoder, a)?;

        ::fidl_next::Encode::encode(self.b, encoder, b)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CalculatorMultiplyRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                a,
                b,

            } = out;
        }

        ::fidl_next::EncodeRef::encode_ref(&self.a, encoder, a)?;

        ::fidl_next::EncodeRef::encode_ref(&self.b, encoder, b)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for CalculatorMultiplyRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireCalculatorMultiplyRequest>;
}

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CalculatorMultiplyRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    CalculatorMultiplyRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireCalculatorMultiplyRequest> for CalculatorMultiplyRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireCalculatorMultiplyRequest, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <f64 as ::fidl_next::FromWire<::fidl_next::WireF64>>::COPY_OPTIMIZATION
                .is_enabled()
                && <f64 as ::fidl_next::FromWire<::fidl_next::WireF64>>::COPY_OPTIMIZATION
                    .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireCalculatorMultiplyRequest) -> Self {
        Self {
            a: ::fidl_next::FromWire::from_wire(wire.a),

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

impl ::fidl_next::FromWireRef<WireCalculatorMultiplyRequest> for CalculatorMultiplyRequest {
    #[inline]
    fn from_wire_ref(wire: &WireCalculatorMultiplyRequest) -> Self {
        Self {
            a: ::fidl_next::FromWireRef::from_wire_ref(&wire.a),

            b: ::fidl_next::FromWireRef::from_wire_ref(&wire.b),
        }
    }
}

/// The wire type corresponding to [`CalculatorMultiplyRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireCalculatorMultiplyRequest {
    pub a: ::fidl_next::WireF64,

    pub b: ::fidl_next::WireF64,
}

unsafe impl ::fidl_next::Wire for WireCalculatorMultiplyRequest {
    type Decoded<'de> = WireCalculatorMultiplyRequest;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCalculatorMultiplyRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut a,
                mut b,

            } = slot;
        }

        ::fidl_next::Decode::decode(a.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(b.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct CalculatorMultiplyResponse {
    pub product: f64,
}

impl ::fidl_next::Encodable for CalculatorMultiplyResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireCalculatorMultiplyResponse> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <f64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireCalculatorMultiplyResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for CalculatorMultiplyResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                product,

            } = out;
        }

        ::fidl_next::Encode::encode(self.product, encoder, product)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CalculatorMultiplyResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                product,

            } = out;
        }

        ::fidl_next::EncodeRef::encode_ref(&self.product, encoder, product)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for CalculatorMultiplyResponse {
    type EncodedOption = ::fidl_next::WireBox<'static, WireCalculatorMultiplyResponse>;
}

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CalculatorMultiplyResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    CalculatorMultiplyResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireCalculatorMultiplyResponse> for CalculatorMultiplyResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireCalculatorMultiplyResponse, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <f64 as ::fidl_next::FromWire<::fidl_next::WireF64>>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireCalculatorMultiplyResponse) -> Self {
        Self { product: ::fidl_next::FromWire::from_wire(wire.product) }
    }
}

impl ::fidl_next::FromWireRef<WireCalculatorMultiplyResponse> for CalculatorMultiplyResponse {
    #[inline]
    fn from_wire_ref(wire: &WireCalculatorMultiplyResponse) -> Self {
        Self { product: ::fidl_next::FromWireRef::from_wire_ref(&wire.product) }
    }
}

/// The wire type corresponding to [`CalculatorMultiplyResponse`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireCalculatorMultiplyResponse {
    pub product: ::fidl_next::WireF64,
}

unsafe impl ::fidl_next::Wire for WireCalculatorMultiplyResponse {
    type Decoded<'de> = WireCalculatorMultiplyResponse;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCalculatorMultiplyResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut product,

            } = slot;
        }

        ::fidl_next::Decode::decode(product.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct CalculatorDivideRequest {
    pub dividend: f64,

    pub divisor: f64,
}

impl ::fidl_next::Encodable for CalculatorDivideRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireCalculatorDivideRequest> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <f64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <f64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireCalculatorDivideRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for CalculatorDivideRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                dividend,
                divisor,

            } = out;
        }

        ::fidl_next::Encode::encode(self.dividend, encoder, dividend)?;

        ::fidl_next::Encode::encode(self.divisor, encoder, divisor)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CalculatorDivideRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                dividend,
                divisor,

            } = out;
        }

        ::fidl_next::EncodeRef::encode_ref(&self.dividend, encoder, dividend)?;

        ::fidl_next::EncodeRef::encode_ref(&self.divisor, encoder, divisor)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for CalculatorDivideRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireCalculatorDivideRequest>;
}

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CalculatorDivideRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    CalculatorDivideRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireCalculatorDivideRequest> for CalculatorDivideRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireCalculatorDivideRequest, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <f64 as ::fidl_next::FromWire<::fidl_next::WireF64>>::COPY_OPTIMIZATION
                .is_enabled()
                && <f64 as ::fidl_next::FromWire<::fidl_next::WireF64>>::COPY_OPTIMIZATION
                    .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireCalculatorDivideRequest) -> Self {
        Self {
            dividend: ::fidl_next::FromWire::from_wire(wire.dividend),

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

impl ::fidl_next::FromWireRef<WireCalculatorDivideRequest> for CalculatorDivideRequest {
    #[inline]
    fn from_wire_ref(wire: &WireCalculatorDivideRequest) -> Self {
        Self {
            dividend: ::fidl_next::FromWireRef::from_wire_ref(&wire.dividend),

            divisor: ::fidl_next::FromWireRef::from_wire_ref(&wire.divisor),
        }
    }
}

/// The wire type corresponding to [`CalculatorDivideRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireCalculatorDivideRequest {
    pub dividend: ::fidl_next::WireF64,

    pub divisor: ::fidl_next::WireF64,
}

unsafe impl ::fidl_next::Wire for WireCalculatorDivideRequest {
    type Decoded<'de> = WireCalculatorDivideRequest;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCalculatorDivideRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut dividend,
                mut divisor,

            } = slot;
        }

        ::fidl_next::Decode::decode(dividend.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(divisor.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct CalculatorDivideResponse {
    pub quotient: f64,
}

impl ::fidl_next::Encodable for CalculatorDivideResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireCalculatorDivideResponse> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <f64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireCalculatorDivideResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for CalculatorDivideResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                quotient,

            } = out;
        }

        ::fidl_next::Encode::encode(self.quotient, encoder, quotient)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CalculatorDivideResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                quotient,

            } = out;
        }

        ::fidl_next::EncodeRef::encode_ref(&self.quotient, encoder, quotient)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for CalculatorDivideResponse {
    type EncodedOption = ::fidl_next::WireBox<'static, WireCalculatorDivideResponse>;
}

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CalculatorDivideResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    CalculatorDivideResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireCalculatorDivideResponse> for CalculatorDivideResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireCalculatorDivideResponse, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <f64 as ::fidl_next::FromWire<::fidl_next::WireF64>>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireCalculatorDivideResponse) -> Self {
        Self { quotient: ::fidl_next::FromWire::from_wire(wire.quotient) }
    }
}

impl ::fidl_next::FromWireRef<WireCalculatorDivideResponse> for CalculatorDivideResponse {
    #[inline]
    fn from_wire_ref(wire: &WireCalculatorDivideResponse) -> Self {
        Self { quotient: ::fidl_next::FromWireRef::from_wire_ref(&wire.quotient) }
    }
}

/// The wire type corresponding to [`CalculatorDivideResponse`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireCalculatorDivideResponse {
    pub quotient: ::fidl_next::WireF64,
}

unsafe impl ::fidl_next::Wire for WireCalculatorDivideResponse {
    type Decoded<'de> = WireCalculatorDivideResponse;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCalculatorDivideResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut quotient,

            } = slot;
        }

        ::fidl_next::Decode::decode(quotient.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct CalculatorPowRequest {
    pub base: f64,

    pub exponent: f64,
}

impl ::fidl_next::Encodable for CalculatorPowRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireCalculatorPowRequest> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <f64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled()
                && <f64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireCalculatorPowRequest;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for CalculatorPowRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                base,
                exponent,

            } = out;
        }

        ::fidl_next::Encode::encode(self.base, encoder, base)?;

        ::fidl_next::Encode::encode(self.exponent, encoder, exponent)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CalculatorPowRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                base,
                exponent,

            } = out;
        }

        ::fidl_next::EncodeRef::encode_ref(&self.base, encoder, base)?;

        ::fidl_next::EncodeRef::encode_ref(&self.exponent, encoder, exponent)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for CalculatorPowRequest {
    type EncodedOption = ::fidl_next::WireBox<'static, WireCalculatorPowRequest>;
}

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CalculatorPowRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    CalculatorPowRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireCalculatorPowRequest> for CalculatorPowRequest {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireCalculatorPowRequest, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <f64 as ::fidl_next::FromWire<::fidl_next::WireF64>>::COPY_OPTIMIZATION
                .is_enabled()
                && <f64 as ::fidl_next::FromWire<::fidl_next::WireF64>>::COPY_OPTIMIZATION
                    .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireCalculatorPowRequest) -> Self {
        Self {
            base: ::fidl_next::FromWire::from_wire(wire.base),

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

impl ::fidl_next::FromWireRef<WireCalculatorPowRequest> for CalculatorPowRequest {
    #[inline]
    fn from_wire_ref(wire: &WireCalculatorPowRequest) -> Self {
        Self {
            base: ::fidl_next::FromWireRef::from_wire_ref(&wire.base),

            exponent: ::fidl_next::FromWireRef::from_wire_ref(&wire.exponent),
        }
    }
}

/// The wire type corresponding to [`CalculatorPowRequest`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireCalculatorPowRequest {
    pub base: ::fidl_next::WireF64,

    pub exponent: ::fidl_next::WireF64,
}

unsafe impl ::fidl_next::Wire for WireCalculatorPowRequest {
    type Decoded<'de> = WireCalculatorPowRequest;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCalculatorPowRequest
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut base,
                mut exponent,

            } = slot;
        }

        ::fidl_next::Decode::decode(base.as_mut(), decoder)?;

        ::fidl_next::Decode::decode(exponent.as_mut(), decoder)?;

        Ok(())
    }
}

#[derive(Clone, Debug)]
#[repr(C)]
pub struct CalculatorPowResponse {
    pub power: f64,
}

impl ::fidl_next::Encodable for CalculatorPowResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<Self, WireCalculatorPowResponse> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <f64 as ::fidl_next::Encodable>::COPY_OPTIMIZATION.is_enabled(),
        )
    };

    type Encoded = WireCalculatorPowResponse;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for CalculatorPowResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                power,

            } = out;
        }

        ::fidl_next::Encode::encode(self.power, encoder, power)?;

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for CalculatorPowResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                power,

            } = out;
        }

        ::fidl_next::EncodeRef::encode_ref(&self.power, encoder, power)?;

        Ok(())
    }
}

impl ::fidl_next::EncodableOption for CalculatorPowResponse {
    type EncodedOption = ::fidl_next::WireBox<'static, WireCalculatorPowResponse>;
}

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

        Ok(())
    }
}

unsafe impl<___E> ::fidl_next::EncodeOptionRef<___E> for CalculatorPowResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    CalculatorPowResponse: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: Option<&Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> Result<(), ::fidl_next::EncodeError> {
        if let Some(inner) = this {
            ::fidl_next::EncoderExt::encode_next(encoder, inner)?;
            ::fidl_next::WireBox::encode_present(out);
        } else {
            ::fidl_next::WireBox::encode_absent(out);
        }

        Ok(())
    }
}

impl ::fidl_next::FromWire<WireCalculatorPowResponse> for CalculatorPowResponse {
    const COPY_OPTIMIZATION: ::fidl_next::CopyOptimization<WireCalculatorPowResponse, Self> = unsafe {
        ::fidl_next::CopyOptimization::enable_if(
            true && <f64 as ::fidl_next::FromWire<::fidl_next::WireF64>>::COPY_OPTIMIZATION
                .is_enabled(),
        )
    };

    #[inline]
    fn from_wire(wire: WireCalculatorPowResponse) -> Self {
        Self { power: ::fidl_next::FromWire::from_wire(wire.power) }
    }
}

impl ::fidl_next::FromWireRef<WireCalculatorPowResponse> for CalculatorPowResponse {
    #[inline]
    fn from_wire_ref(wire: &WireCalculatorPowResponse) -> Self {
        Self { power: ::fidl_next::FromWireRef::from_wire_ref(&wire.power) }
    }
}

/// The wire type corresponding to [`CalculatorPowResponse`].
#[derive(Clone, Debug)]
#[repr(C)]
pub struct WireCalculatorPowResponse {
    pub power: ::fidl_next::WireF64,
}

unsafe impl ::fidl_next::Wire for WireCalculatorPowResponse {
    type Decoded<'de> = WireCalculatorPowResponse;

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {}
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireCalculatorPowResponse
where
    ___D: ::fidl_next::decoder::InternalHandleDecoder + ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge! {
            let Self {
                mut power,

            } = slot;
        }

        ::fidl_next::Decode::decode(power.as_mut(), decoder)?;

        Ok(())
    }
}

/// The type corresponding to the Calculator protocol.
#[doc = " A protocol for a simple calculator.\n\n Supports the following operations:\n + [`fuchsia.examples.calculator/Calculator.Add`]\n + [`fuchsia.examples.calculator/Calculator.Subtract`]\n + [`fuchsia.examples.calculator/Calculator.Multiply`]\n + [`fuchsia.examples.calculator/Calculator.Divide`]\n + [`fuchsia.examples.calculator/Calculator.Pow`]\n"]
#[derive(Debug)]
pub struct Calculator;

impl ::fidl_next::Discoverable for Calculator {
    const PROTOCOL_NAME: &'static str = "fuchsia.examples.calculator.Calculator";
}

pub mod calculator {
    pub mod prelude {
        pub use crate::{Calculator, CalculatorClientHandler, CalculatorServerHandler, calculator};

        pub use crate::CalculatorAddRequest;

        pub use crate::CalculatorAddResponse;

        pub use crate::CalculatorDivideRequest;

        pub use crate::CalculatorDivideResponse;

        pub use crate::CalculatorMultiplyRequest;

        pub use crate::CalculatorMultiplyResponse;

        pub use crate::CalculatorPowRequest;

        pub use crate::CalculatorPowResponse;

        pub use crate::CalculatorSubtractRequest;

        pub use crate::CalculatorSubtractResponse;
    }

    pub struct Add;

    impl ::fidl_next::Method for Add {
        const ORDINAL: u64 = 6855189016650709278;

        type Protocol = crate::Calculator;

        type Request = crate::WireCalculatorAddRequest;

        type Response = crate::WireCalculatorAddResponse;
    }

    pub struct Subtract;

    impl ::fidl_next::Method for Subtract {
        const ORDINAL: u64 = 7263901511078514040;

        type Protocol = crate::Calculator;

        type Request = crate::WireCalculatorSubtractRequest;

        type Response = crate::WireCalculatorSubtractResponse;
    }

    pub struct Multiply;

    impl ::fidl_next::Method for Multiply {
        const ORDINAL: u64 = 5579939962788903989;

        type Protocol = crate::Calculator;

        type Request = crate::WireCalculatorMultiplyRequest;

        type Response = crate::WireCalculatorMultiplyResponse;
    }

    pub struct Divide;

    impl ::fidl_next::Method for Divide {
        const ORDINAL: u64 = 5603396952649205946;

        type Protocol = crate::Calculator;

        type Request = crate::WireCalculatorDivideRequest;

        type Response = crate::WireCalculatorDivideResponse;
    }

    pub struct Pow;

    impl ::fidl_next::Method for Pow {
        const ORDINAL: u64 = 3776118813804437910;

        type Protocol = crate::Calculator;

        type Request = crate::WireCalculatorPowRequest;

        type Response = crate::WireCalculatorPowResponse;
    }

    mod ___detail {

        pub struct Add<T0, T1> {
            a: T0,

            b: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for Add<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireF64>,
            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireF64>,
        {
            type Encoded = crate::WireCalculatorAddRequest;
        }

        unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for Add<T0, T1>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireF64>,
            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireF64>,
        {
            #[inline]
            fn encode(
                self,
                encoder: &mut ___E,
                out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
            ) -> Result<(), ::fidl_next::EncodeError> {
                ::fidl_next::munge! {
                    let Self::Encoded {
                        a,
                        b,

                    } = out;
                }

                ::fidl_next::Encode::encode(self.a, encoder, a)?;

                ::fidl_next::Encode::encode(self.b, encoder, b)?;

                Ok(())
            }
        }

        pub struct Subtract<T0, T1> {
            a: T0,

            b: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for Subtract<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireF64>,
            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireF64>,
        {
            type Encoded = crate::WireCalculatorSubtractRequest;
        }

        unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for Subtract<T0, T1>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireF64>,
            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireF64>,
        {
            #[inline]
            fn encode(
                self,
                encoder: &mut ___E,
                out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
            ) -> Result<(), ::fidl_next::EncodeError> {
                ::fidl_next::munge! {
                    let Self::Encoded {
                        a,
                        b,

                    } = out;
                }

                ::fidl_next::Encode::encode(self.a, encoder, a)?;

                ::fidl_next::Encode::encode(self.b, encoder, b)?;

                Ok(())
            }
        }

        pub struct Multiply<T0, T1> {
            a: T0,

            b: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for Multiply<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireF64>,
            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireF64>,
        {
            type Encoded = crate::WireCalculatorMultiplyRequest;
        }

        unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for Multiply<T0, T1>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireF64>,
            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireF64>,
        {
            #[inline]
            fn encode(
                self,
                encoder: &mut ___E,
                out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
            ) -> Result<(), ::fidl_next::EncodeError> {
                ::fidl_next::munge! {
                    let Self::Encoded {
                        a,
                        b,

                    } = out;
                }

                ::fidl_next::Encode::encode(self.a, encoder, a)?;

                ::fidl_next::Encode::encode(self.b, encoder, b)?;

                Ok(())
            }
        }

        pub struct Divide<T0, T1> {
            dividend: T0,

            divisor: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for Divide<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireF64>,
            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireF64>,
        {
            type Encoded = crate::WireCalculatorDivideRequest;
        }

        unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for Divide<T0, T1>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireF64>,
            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireF64>,
        {
            #[inline]
            fn encode(
                self,
                encoder: &mut ___E,
                out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
            ) -> Result<(), ::fidl_next::EncodeError> {
                ::fidl_next::munge! {
                    let Self::Encoded {
                        dividend,
                        divisor,

                    } = out;
                }

                ::fidl_next::Encode::encode(self.dividend, encoder, dividend)?;

                ::fidl_next::Encode::encode(self.divisor, encoder, divisor)?;

                Ok(())
            }
        }

        pub struct Pow<T0, T1> {
            base: T0,

            exponent: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for Pow<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireF64>,
            T1: ::fidl_next::Encodable<Encoded = ::fidl_next::WireF64>,
        {
            type Encoded = crate::WireCalculatorPowRequest;
        }

        unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for Pow<T0, T1>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireF64>,
            T1: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireF64>,
        {
            #[inline]
            fn encode(
                self,
                encoder: &mut ___E,
                out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
            ) -> Result<(), ::fidl_next::EncodeError> {
                ::fidl_next::munge! {
                    let Self::Encoded {
                        base,
                        exponent,

                    } = out;
                }

                ::fidl_next::Encode::encode(self.base, encoder, base)?;

                ::fidl_next::Encode::encode(self.exponent, encoder, exponent)?;

                Ok(())
            }
        }

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::Calculator
        where
            ___T: ::fidl_next::Transport,
        {
            type ClientSender = CalculatorClientSender<___T>;
            type ServerSender = CalculatorServerSender<___T>;
        }

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

        impl<___T> CalculatorClientSender<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            #[doc = " Adds two numbers together and returns their `sum`.\n\n For example, with `a` being 4.5 and `b` being 3.2, the response `sum` is\n 7.7.\n\n + request `a` the first number to be added.\n + request `b` the second number to be added.\n - response `sum` the sum of a and b.\n"]
            pub fn add(
                &self,

                a: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireF64,
                >,

                b: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireF64,
                >,
            ) -> ::fidl_next::TwoWayFuture<'_, super::Add, ___T>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.add_with(Add { a, b })
            }

            #[doc = " Adds two numbers together and returns their `sum`.\n\n For example, with `a` being 4.5 and `b` being 3.2, the response `sum` is\n 7.7.\n\n + request `a` the first number to be added.\n + request `b` the second number to be added.\n - response `sum` the sum of a and b.\n"]
            pub fn add_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::TwoWayFuture<'_, super::Add, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <___T as ::fidl_next::Transport>::SendBuffer,
                        Encoded = crate::WireCalculatorAddRequest,
                    >,
            {
                ::fidl_next::TwoWayFuture::from_untyped(
                    self.sender.send_two_way(6855189016650709278, request),
                )
            }

            #[doc = " Subtracts two numbers and returns their `difference`.\n\n For example, with `a` being 7.7 and `b` being 3.2, the response\n `difference` is 4.5\n\n + request `a` the number to be subracted _from_.\n + request `b` the number to subtract.\n - response `difference` the difference between `a` and `b`.\n"]
            pub fn subtract(
                &self,

                a: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireF64,
                >,

                b: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireF64,
                >,
            ) -> ::fidl_next::TwoWayFuture<'_, super::Subtract, ___T>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.subtract_with(Subtract { a, b })
            }

            #[doc = " Subtracts two numbers and returns their `difference`.\n\n For example, with `a` being 7.7 and `b` being 3.2, the response\n `difference` is 4.5\n\n + request `a` the number to be subracted _from_.\n + request `b` the number to subtract.\n - response `difference` the difference between `a` and `b`.\n"]
            pub fn subtract_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::TwoWayFuture<'_, super::Subtract, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <___T as ::fidl_next::Transport>::SendBuffer,
                        Encoded = crate::WireCalculatorSubtractRequest,
                    >,
            {
                ::fidl_next::TwoWayFuture::from_untyped(
                    self.sender.send_two_way(7263901511078514040, request),
                )
            }

            #[doc = " Multiplies two numbers and returns their `product`.\n\n For example, with `a` being 1.5 and `b` being 2.0, the response\n `product` is 3.0\n\n + request `a` the first number used to calculatorulate the `product`.\n + request `b` the second number used to calculatorulate the `product`.\n - response `product` the result of multiplying `a` and `b`.\n"]
            pub fn multiply(
                &self,

                a: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireF64,
                >,

                b: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireF64,
                >,
            ) -> ::fidl_next::TwoWayFuture<'_, super::Multiply, ___T>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.multiply_with(Multiply { a, b })
            }

            #[doc = " Multiplies two numbers and returns their `product`.\n\n For example, with `a` being 1.5 and `b` being 2.0, the response\n `product` is 3.0\n\n + request `a` the first number used to calculatorulate the `product`.\n + request `b` the second number used to calculatorulate the `product`.\n - response `product` the result of multiplying `a` and `b`.\n"]
            pub fn multiply_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::TwoWayFuture<'_, super::Multiply, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <___T as ::fidl_next::Transport>::SendBuffer,
                        Encoded = crate::WireCalculatorMultiplyRequest,
                    >,
            {
                ::fidl_next::TwoWayFuture::from_untyped(
                    self.sender.send_two_way(5579939962788903989, request),
                )
            }

            #[doc = " Divides one number by another and return the `quotient`.\n\n For example with a `dividend` of 2.0 and a `divisor` of 4.0, the\n response `quotient` is 0.5.\n\n + request `dividend` the number to divide with.\n + request `divisor` the number to divide into.\n - response `quotient` the result of dividing the `dividend` into the `divisor`.\n"]
            pub fn divide(
                &self,

                dividend: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireF64,
                >,

                divisor: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireF64,
                >,
            ) -> ::fidl_next::TwoWayFuture<'_, super::Divide, ___T>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.divide_with(Divide { dividend, divisor })
            }

            #[doc = " Divides one number by another and return the `quotient`.\n\n For example with a `dividend` of 2.0 and a `divisor` of 4.0, the\n response `quotient` is 0.5.\n\n + request `dividend` the number to divide with.\n + request `divisor` the number to divide into.\n - response `quotient` the result of dividing the `dividend` into the `divisor`.\n"]
            pub fn divide_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::TwoWayFuture<'_, super::Divide, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <___T as ::fidl_next::Transport>::SendBuffer,
                        Encoded = crate::WireCalculatorDivideRequest,
                    >,
            {
                ::fidl_next::TwoWayFuture::from_untyped(
                    self.sender.send_two_way(5603396952649205946, request),
                )
            }

            #[doc = " Takes `base` to the `exponent` and returns the `power`.\n\n For example with a `base` of 3.0 and an `exponent` of 4.0, the response\n `power` is 81.0.\n\n + request `base` the number to multiply by itself.\n + request `exponent` the number of times to successively multiply\n `base`.\n - response `power` the result of multiplying `base` by itself `exponent`\n times..\n"]
            pub fn pow(
                &self,

                base: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireF64,
                >,

                exponent: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireF64,
                >,
            ) -> ::fidl_next::TwoWayFuture<'_, super::Pow, ___T>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
            {
                self.pow_with(Pow { base, exponent })
            }

            #[doc = " Takes `base` to the `exponent` and returns the `power`.\n\n For example with a `base` of 3.0 and an `exponent` of 4.0, the response\n `power` is 81.0.\n\n + request `base` the number to multiply by itself.\n + request `exponent` the number of times to successively multiply\n `base`.\n - response `power` the result of multiplying `base` by itself `exponent`\n times..\n"]
            pub fn pow_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::TwoWayFuture<'_, super::Pow, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <___T as ::fidl_next::Transport>::SendBuffer,
                        Encoded = crate::WireCalculatorPowRequest,
                    >,
            {
                ::fidl_next::TwoWayFuture::from_untyped(
                    self.sender.send_two_way(3776118813804437910, request),
                )
            }
        }

        /// The server sender for the `Calculator` protocol.
        #[repr(transparent)]
        pub struct CalculatorServerSender<___T: ::fidl_next::Transport> {
            sender: ::fidl_next::protocol::ServerSender<___T>,
        }

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

/// A client handler for the Calculator protocol.
///
/// See [`Calculator`] for more details.
pub trait CalculatorClientHandler<
    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
>
{
}

impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Calculator
where
    ___H: CalculatorClientHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
    <calculator::Add as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <calculator::Subtract as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <calculator::Multiply as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <calculator::Divide as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <calculator::Pow as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_event(
        handler: &mut ___H,
        sender: &::fidl_next::ClientSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => sender.close(),
        }
    }
}

/// A server handler for the Calculator protocol.
///
/// See [`Calculator`] for more details.
pub trait CalculatorServerHandler<
    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
>
{
    #[doc = " Adds two numbers together and returns their `sum`.\n\n For example, with `a` being 4.5 and `b` being 3.2, the response `sum` is\n 7.7.\n\n + request `a` the first number to be added.\n + request `b` the second number to be added.\n - response `sum` the sum of a and b.\n"]
    fn add(
        &mut self,
        sender: &::fidl_next::ServerSender<Calculator, ___T>,

        request: ::fidl_next::Request<calculator::Add, ___T>,

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

    #[doc = " Subtracts two numbers and returns their `difference`.\n\n For example, with `a` being 7.7 and `b` being 3.2, the response\n `difference` is 4.5\n\n + request `a` the number to be subracted _from_.\n + request `b` the number to subtract.\n - response `difference` the difference between `a` and `b`.\n"]
    fn subtract(
        &mut self,
        sender: &::fidl_next::ServerSender<Calculator, ___T>,

        request: ::fidl_next::Request<calculator::Subtract, ___T>,

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

    #[doc = " Multiplies two numbers and returns their `product`.\n\n For example, with `a` being 1.5 and `b` being 2.0, the response\n `product` is 3.0\n\n + request `a` the first number used to calculatorulate the `product`.\n + request `b` the second number used to calculatorulate the `product`.\n - response `product` the result of multiplying `a` and `b`.\n"]
    fn multiply(
        &mut self,
        sender: &::fidl_next::ServerSender<Calculator, ___T>,

        request: ::fidl_next::Request<calculator::Multiply, ___T>,

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

    #[doc = " Divides one number by another and return the `quotient`.\n\n For example with a `dividend` of 2.0 and a `divisor` of 4.0, the\n response `quotient` is 0.5.\n\n + request `dividend` the number to divide with.\n + request `divisor` the number to divide into.\n - response `quotient` the result of dividing the `dividend` into the `divisor`.\n"]
    fn divide(
        &mut self,
        sender: &::fidl_next::ServerSender<Calculator, ___T>,

        request: ::fidl_next::Request<calculator::Divide, ___T>,

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

    #[doc = " Takes `base` to the `exponent` and returns the `power`.\n\n For example with a `base` of 3.0 and an `exponent` of 4.0, the response\n `power` is 81.0.\n\n + request `base` the number to multiply by itself.\n + request `exponent` the number of times to successively multiply\n `base`.\n - response `power` the result of multiplying `base` by itself `exponent`\n times..\n"]
    fn pow(
        &mut self,
        sender: &::fidl_next::ServerSender<Calculator, ___T>,

        request: ::fidl_next::Request<calculator::Pow, ___T>,

        responder: ::fidl_next::Responder<calculator::Pow>,
    ) -> impl ::core::future::Future<Output = ()> + ::core::marker::Send;
}

impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Calculator
where
    ___H: CalculatorServerHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
    <calculator::Add as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <calculator::Subtract as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <calculator::Multiply as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <calculator::Divide as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <calculator::Pow as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_one_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) {
        match ordinal {
            ordinal => sender.close(),
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        sender: &::fidl_next::ServerSender<Self, ___T>,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder,
    ) {
        match ordinal {
            6855189016650709278 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.add(sender, decoded, responder).await,
                    Err(e) => sender.close(),
                }
            }

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

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.subtract(sender, decoded, responder).await,
                    Err(e) => sender.close(),
                }
            }

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

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.multiply(sender, decoded, responder).await,
                    Err(e) => sender.close(),
                }
            }

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

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.divide(sender, decoded, responder).await,
                    Err(e) => sender.close(),
                }
            }

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

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => handler.pow(sender, decoded, responder).await,
                    Err(e) => sender.close(),
                }
            }

            ordinal => sender.close(),
        }
    }
}

/// Compatibility shims which mimic some API surfaces of the current Rust bindings.
pub mod compat {

    impl ::fidl_next::CompatFrom<crate::CalculatorAddRequest>
        for ::fidl_fuchsia_examples_calculator::CalculatorAddRequest
    {
        #[inline]
        fn compat_from(value: crate::CalculatorAddRequest) -> Self {
            Self {
                a: ::fidl_next::CompatFrom::compat_from(value.a),

                b: ::fidl_next::CompatFrom::compat_from(value.b),
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_examples_calculator::CalculatorAddRequest>
        for crate::CalculatorAddRequest
    {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_examples_calculator::CalculatorAddRequest) -> Self {
            Self {
                a: ::fidl_next::CompatFrom::compat_from(value.a),

                b: ::fidl_next::CompatFrom::compat_from(value.b),
            }
        }
    }

    impl ::fidl_next::CompatFrom<crate::CalculatorAddResponse>
        for ::fidl_fuchsia_examples_calculator::CalculatorAddResponse
    {
        #[inline]
        fn compat_from(value: crate::CalculatorAddResponse) -> Self {
            Self { sum: ::fidl_next::CompatFrom::compat_from(value.sum) }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_examples_calculator::CalculatorAddResponse>
        for crate::CalculatorAddResponse
    {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_examples_calculator::CalculatorAddResponse) -> Self {
            Self { sum: ::fidl_next::CompatFrom::compat_from(value.sum) }
        }
    }

    impl ::fidl_next::CompatFrom<crate::CalculatorSubtractRequest>
        for ::fidl_fuchsia_examples_calculator::CalculatorSubtractRequest
    {
        #[inline]
        fn compat_from(value: crate::CalculatorSubtractRequest) -> Self {
            Self {
                a: ::fidl_next::CompatFrom::compat_from(value.a),

                b: ::fidl_next::CompatFrom::compat_from(value.b),
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_examples_calculator::CalculatorSubtractRequest>
        for crate::CalculatorSubtractRequest
    {
        #[inline]
        fn compat_from(
            value: ::fidl_fuchsia_examples_calculator::CalculatorSubtractRequest,
        ) -> Self {
            Self {
                a: ::fidl_next::CompatFrom::compat_from(value.a),

                b: ::fidl_next::CompatFrom::compat_from(value.b),
            }
        }
    }

    impl ::fidl_next::CompatFrom<crate::CalculatorSubtractResponse>
        for ::fidl_fuchsia_examples_calculator::CalculatorSubtractResponse
    {
        #[inline]
        fn compat_from(value: crate::CalculatorSubtractResponse) -> Self {
            Self { difference: ::fidl_next::CompatFrom::compat_from(value.difference) }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_examples_calculator::CalculatorSubtractResponse>
        for crate::CalculatorSubtractResponse
    {
        #[inline]
        fn compat_from(
            value: ::fidl_fuchsia_examples_calculator::CalculatorSubtractResponse,
        ) -> Self {
            Self { difference: ::fidl_next::CompatFrom::compat_from(value.difference) }
        }
    }

    impl ::fidl_next::CompatFrom<crate::CalculatorMultiplyRequest>
        for ::fidl_fuchsia_examples_calculator::CalculatorMultiplyRequest
    {
        #[inline]
        fn compat_from(value: crate::CalculatorMultiplyRequest) -> Self {
            Self {
                a: ::fidl_next::CompatFrom::compat_from(value.a),

                b: ::fidl_next::CompatFrom::compat_from(value.b),
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_examples_calculator::CalculatorMultiplyRequest>
        for crate::CalculatorMultiplyRequest
    {
        #[inline]
        fn compat_from(
            value: ::fidl_fuchsia_examples_calculator::CalculatorMultiplyRequest,
        ) -> Self {
            Self {
                a: ::fidl_next::CompatFrom::compat_from(value.a),

                b: ::fidl_next::CompatFrom::compat_from(value.b),
            }
        }
    }

    impl ::fidl_next::CompatFrom<crate::CalculatorMultiplyResponse>
        for ::fidl_fuchsia_examples_calculator::CalculatorMultiplyResponse
    {
        #[inline]
        fn compat_from(value: crate::CalculatorMultiplyResponse) -> Self {
            Self { product: ::fidl_next::CompatFrom::compat_from(value.product) }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_examples_calculator::CalculatorMultiplyResponse>
        for crate::CalculatorMultiplyResponse
    {
        #[inline]
        fn compat_from(
            value: ::fidl_fuchsia_examples_calculator::CalculatorMultiplyResponse,
        ) -> Self {
            Self { product: ::fidl_next::CompatFrom::compat_from(value.product) }
        }
    }

    impl ::fidl_next::CompatFrom<crate::CalculatorDivideRequest>
        for ::fidl_fuchsia_examples_calculator::CalculatorDivideRequest
    {
        #[inline]
        fn compat_from(value: crate::CalculatorDivideRequest) -> Self {
            Self {
                dividend: ::fidl_next::CompatFrom::compat_from(value.dividend),

                divisor: ::fidl_next::CompatFrom::compat_from(value.divisor),
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_examples_calculator::CalculatorDivideRequest>
        for crate::CalculatorDivideRequest
    {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_examples_calculator::CalculatorDivideRequest) -> Self {
            Self {
                dividend: ::fidl_next::CompatFrom::compat_from(value.dividend),

                divisor: ::fidl_next::CompatFrom::compat_from(value.divisor),
            }
        }
    }

    impl ::fidl_next::CompatFrom<crate::CalculatorDivideResponse>
        for ::fidl_fuchsia_examples_calculator::CalculatorDivideResponse
    {
        #[inline]
        fn compat_from(value: crate::CalculatorDivideResponse) -> Self {
            Self { quotient: ::fidl_next::CompatFrom::compat_from(value.quotient) }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_examples_calculator::CalculatorDivideResponse>
        for crate::CalculatorDivideResponse
    {
        #[inline]
        fn compat_from(
            value: ::fidl_fuchsia_examples_calculator::CalculatorDivideResponse,
        ) -> Self {
            Self { quotient: ::fidl_next::CompatFrom::compat_from(value.quotient) }
        }
    }

    impl ::fidl_next::CompatFrom<crate::CalculatorPowRequest>
        for ::fidl_fuchsia_examples_calculator::CalculatorPowRequest
    {
        #[inline]
        fn compat_from(value: crate::CalculatorPowRequest) -> Self {
            Self {
                base: ::fidl_next::CompatFrom::compat_from(value.base),

                exponent: ::fidl_next::CompatFrom::compat_from(value.exponent),
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_examples_calculator::CalculatorPowRequest>
        for crate::CalculatorPowRequest
    {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_examples_calculator::CalculatorPowRequest) -> Self {
            Self {
                base: ::fidl_next::CompatFrom::compat_from(value.base),

                exponent: ::fidl_next::CompatFrom::compat_from(value.exponent),
            }
        }
    }

    impl ::fidl_next::CompatFrom<crate::CalculatorPowResponse>
        for ::fidl_fuchsia_examples_calculator::CalculatorPowResponse
    {
        #[inline]
        fn compat_from(value: crate::CalculatorPowResponse) -> Self {
            Self { power: ::fidl_next::CompatFrom::compat_from(value.power) }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_examples_calculator::CalculatorPowResponse>
        for crate::CalculatorPowResponse
    {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_examples_calculator::CalculatorPowResponse) -> Self {
            Self { power: ::fidl_next::CompatFrom::compat_from(value.power) }
        }
    }

    #[cfg(target_os = "fuchsia")]
    /// An alias for a client sender over `zx::Channel` for the `Calculator`
    /// protocol.
    pub type CalculatorProxy = ::fidl_next::ClientSender<crate::Calculator>;

    impl ::fidl_next::CompatFrom<crate::Calculator>
        for ::fidl_fuchsia_examples_calculator::CalculatorMarker
    {
        fn compat_from(_: crate::Calculator) -> Self {
            Self
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_examples_calculator::CalculatorMarker>
        for crate::Calculator
    {
        fn compat_from(_: ::fidl_fuchsia_examples_calculator::CalculatorMarker) -> Self {
            Self
        }
    }

    #[cfg(target_os = "fuchsia")]

    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_examples_calculator::CalculatorProxy>
        for crate::Calculator
    {
        fn client_compat_from(
            proxy: ::fidl_fuchsia_examples_calculator::CalculatorProxy,
        ) -> ::fidl_next::Client<Self, ::fidl_next::fuchsia::zx::Channel> {
            let channel = ::fidl::endpoints::Proxy::into_channel(proxy).unwrap().into_zx_channel();
            let client_end = ::fidl_next::ClientEnd::from_untyped(channel);
            ::fidl_next::Client::new(client_end)
        }
    }
}