fidl_next_fuchsia_component_resolution/

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

#[doc = " Max length of component URL.\n"]
pub const MAX_COMPONENT_URL_LENGTH: u32 = 2083 as u32;

#[doc = " The maximum number of bytes for a `Context`.\n"]
pub const MAX_RESOLUTION_CONTEXT_SIZE: u32 = 8192 as u32;

#[doc = " A component resolution context, used when resolving component URLs relative\n to another component. The context is stored in a byte array that persists a\n value used by the target `Resolver` to locate and resolve a component by\n relative path (for example, by a subpackage name).\n"]
#[derive(PartialEq, Clone, Debug)]
pub struct Context {
    pub bytes: ::std::vec::Vec<u8>,
}

impl ::fidl_next::Encodable for Context {
    type Encoded = WireContext<'static>;
}

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

            } = out_;
        }

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

        Ok(())
    }
}

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

                bytes,

            } = out_;
        }

        ::fidl_next::EncodeRef::encode_ref(&self.bytes, encoder_, bytes)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for Context
where
    ___E: ::fidl_next::Encoder + ?Sized,
    Context: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: ::core::option::Option<Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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 Context
where
    ___E: ::fidl_next::Encoder + ?Sized,
    Context: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: ::core::option::Option<&Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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<'de> ::fidl_next::FromWire<WireContext<'de>> for Context {
    #[inline]
    fn from_wire(wire: WireContext<'de>) -> Self {
        Self { bytes: ::fidl_next::FromWire::from_wire(wire.bytes) }
    }
}

impl<'de> ::fidl_next::IntoNatural for WireContext<'de> {
    type Natural = Context;
}

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

/// The wire type corresponding to [`Context`].
#[derive(Debug)]
#[repr(C)]
pub struct WireContext<'de> {
    pub bytes: ::fidl_next::WireVector<'de, u8>,
}
static_assertions::const_assert_eq!(std::mem::size_of::<WireContext<'_>>(), 16);
static_assertions::const_assert_eq!(std::mem::align_of::<WireContext<'_>>(), 8);

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

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

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

                bytes,

            } = &mut *out_;
        }

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

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

                mut bytes,

            } = slot_;
        }

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

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

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

        Ok(())
    }
}

#[doc = " A package is a signed collection of immutable files.\n\n This object provides access to a package\'s content and relevant metadata.\n"]
#[derive(PartialEq, Debug, Default)]
pub struct Package {
    pub url: ::core::option::Option<::std::string::String>,

    pub directory: ::core::option::Option<
        ::fidl_next::ClientEnd<
            ::fidl_next_fuchsia_io::Directory,
            ::fidl_next::fuchsia::zx::Channel,
        >,
    >,
}

impl Package {
    fn __max_ordinal(&self) -> usize {
        if self.directory.is_some() {
            return 2;
        }

        if self.url.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for Package {
    type Encoded = WirePackage<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Package
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WirePackage { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                2 => {
                    if let Some(value) = self.directory.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            value,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(value) = self.url.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            value,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WirePackage<'de>> for Package {
    #[inline]
    fn from_wire(wire_: WirePackage<'de>) -> Self {
        let wire_ = ::core::mem::ManuallyDrop::new(wire_);

        let url = wire_.table.get(1);

        let directory = wire_.table.get(2);

        Self {
            url: url.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            directory: directory.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::ClientEnd<
                        ::fidl_next_fuchsia_io::Directory,
                        ::fidl_next::fuchsia::WireChannel,
                    >>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::IntoNatural for WirePackage<'de> {
    type Natural = Package;
}

/// The wire type corresponding to [`Package`].
#[repr(C)]
pub struct WirePackage<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WirePackage<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self.table.get(2).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next::ClientEnd<
                ::fidl_next_fuchsia_io::Directory,
                ::fidl_next::fuchsia::WireChannel,
            >>()
        });
    }
}

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WirePackage<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let value = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next::ClientEnd<
                            ::fidl_next_fuchsia_io::Directory,
                            ::fidl_next::fuchsia::WireChannel,
                        >,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WirePackage<'de> {
    pub fn url(&self) -> ::core::option::Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn directory(
        &self,
    ) -> ::core::option::Option<
        &::fidl_next::ClientEnd<
            ::fidl_next_fuchsia_io::Directory,
            ::fidl_next::fuchsia::WireChannel,
        >,
    > {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WirePackage<'de> {
    fn fmt(
        &self,
        f: &mut ::core::fmt::Formatter<'_>,
    ) -> ::core::result::Result<(), ::core::fmt::Error> {
        f.debug_struct("Package")
            .field("url", &self.url())
            .field("directory", &self.directory())
            .finish()
    }
}

#[doc = " A component is a unit of executable software.\n\n This object provides the component\'s declaration, access to its package\'s\n content, and relevant metadata as resolved `fuchsia.component.resolution.Resolver`.\n"]
#[derive(PartialEq, Debug, Default)]
pub struct Component {
    pub url: ::core::option::Option<::std::string::String>,

    pub decl: ::core::option::Option<::fidl_next_fuchsia_mem::Data>,

    pub package: ::core::option::Option<crate::Package>,

    pub config_values: ::core::option::Option<::fidl_next_fuchsia_mem::Data>,

    pub resolution_context: ::core::option::Option<crate::Context>,

    pub abi_revision: ::core::option::Option<u64>,
}

impl Component {
    fn __max_ordinal(&self) -> usize {
        if self.abi_revision.is_some() {
            return 6;
        }

        if self.resolution_context.is_some() {
            return 5;
        }

        if self.config_values.is_some() {
            return 4;
        }

        if self.package.is_some() {
            return 3;
        }

        if self.decl.is_some() {
            return 2;
        }

        if self.url.is_some() {
            return 1;
        }

        0
    }
}

impl ::fidl_next::Encodable for Component {
    type Encoded = WireComponent<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for Component
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        mut self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireComponent { table } = out);

        let max_ord = self.__max_ordinal();

        let mut out = ::core::mem::MaybeUninit::<::fidl_next::WireEnvelope>::uninit();
        ::fidl_next::Wire::zero_padding(&mut out);

        let mut preallocated =
            ::fidl_next::EncoderExt::preallocate::<::fidl_next::WireEnvelope>(encoder, max_ord);

        for i in 1..=max_ord {
            match i {
                6 => {
                    if let Some(value) = self.abi_revision.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            value,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                5 => {
                    if let Some(value) = self.resolution_context.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            value,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                4 => {
                    if let Some(value) = self.config_values.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            value,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                3 => {
                    if let Some(value) = self.package.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            value,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                2 => {
                    if let Some(value) = self.decl.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            value,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                1 => {
                    if let Some(value) = self.url.take() {
                        ::fidl_next::WireEnvelope::encode_value(
                            value,
                            preallocated.encoder,
                            &mut out,
                        )?;
                    } else {
                        ::fidl_next::WireEnvelope::encode_zero(&mut out)
                    }
                }

                _ => ::fidl_next::WireEnvelope::encode_zero(&mut out),
            }
            unsafe {
                preallocated.write_next(out.assume_init_ref());
            }
        }

        ::fidl_next::WireTable::encode_len(table, max_ord);

        Ok(())
    }
}

impl<'de> ::fidl_next::FromWire<WireComponent<'de>> for Component {
    #[inline]
    fn from_wire(wire_: WireComponent<'de>) -> Self {
        let wire_ = ::core::mem::ManuallyDrop::new(wire_);

        let url = wire_.table.get(1);

        let decl = wire_.table.get(2);

        let package = wire_.table.get(3);

        let config_values = wire_.table.get(4);

        let resolution_context = wire_.table.get(5);

        let abi_revision = wire_.table.get(6);

        Self {
            url: url.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireString<'de>>()
                })
            }),

            decl: decl.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next_fuchsia_mem::WireData<'de>>()
                })
            }),

            package: package.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WirePackage<'de>>()
                })
            }),

            config_values: config_values.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next_fuchsia_mem::WireData<'de>>()
                })
            }),

            resolution_context: resolution_context.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<crate::WireContext<'de>>()
                })
            }),

            abi_revision: abi_revision.map(|envelope| {
                ::fidl_next::FromWire::from_wire(unsafe {
                    envelope.read_unchecked::<::fidl_next::WireU64>()
                })
            }),
        }
    }
}

impl<'de> ::fidl_next::IntoNatural for WireComponent<'de> {
    type Natural = Component;
}

/// The wire type corresponding to [`Component`].
#[repr(C)]
pub struct WireComponent<'de> {
    table: ::fidl_next::WireTable<'de>,
}

impl<'de> Drop for WireComponent<'de> {
    fn drop(&mut self) {
        let _ = self
            .table
            .get(1)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireString<'de>>() });

        let _ = self.table.get(2).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next_fuchsia_mem::WireData<'de>>()
        });

        let _ = self
            .table
            .get(3)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WirePackage<'de>>() });

        let _ = self.table.get(4).map(|envelope| unsafe {
            envelope.read_unchecked::<::fidl_next_fuchsia_mem::WireData<'de>>()
        });

        let _ = self
            .table
            .get(5)
            .map(|envelope| unsafe { envelope.read_unchecked::<crate::WireContext<'de>>() });

        let _ = self
            .table
            .get(6)
            .map(|envelope| unsafe { envelope.read_unchecked::<::fidl_next::WireU64>() });
    }
}

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

    #[inline]
    fn zero_padding(out: &mut ::core::mem::MaybeUninit<Self>) {
        ::fidl_next::munge!(let Self { table } = out);
        ::fidl_next::WireTable::zero_padding(table);
    }
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireComponent<'static>
where
    ___D: ::fidl_next::Decoder + ?Sized,
    ___D: ::fidl_next::fuchsia::HandleDecoder,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        decoder: &mut ___D,
    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { table } = slot);

        ::fidl_next::WireTable::decode_with(table, decoder, |ordinal, mut slot, decoder| {
            match ordinal {
                0 => unsafe { ::core::hint::unreachable_unchecked() },

                1 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireString<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    let value = unsafe {
                        slot.deref_unchecked().deref_unchecked::<::fidl_next::WireString<'_>>()
                    };

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

                    Ok(())
                }

                2 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next_fuchsia_mem::WireData<'static>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                3 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WirePackage<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                4 => {
                    ::fidl_next::WireEnvelope::decode_as::<
                        ___D,
                        ::fidl_next_fuchsia_mem::WireData<'static>,
                    >(slot.as_mut(), decoder)?;

                    Ok(())
                }

                5 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, crate::WireContext<'static>>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                6 => {
                    ::fidl_next::WireEnvelope::decode_as::<___D, ::fidl_next::WireU64>(
                        slot.as_mut(),
                        decoder,
                    )?;

                    Ok(())
                }

                _ => ::fidl_next::WireEnvelope::decode_unknown(slot, decoder),
            }
        })
    }
}

impl<'de> WireComponent<'de> {
    pub fn url(&self) -> ::core::option::Option<&::fidl_next::WireString<'de>> {
        unsafe { Some(self.table.get(1)?.deref_unchecked()) }
    }

    pub fn decl(&self) -> ::core::option::Option<&::fidl_next_fuchsia_mem::WireData<'de>> {
        unsafe { Some(self.table.get(2)?.deref_unchecked()) }
    }

    pub fn package(&self) -> ::core::option::Option<&crate::WirePackage<'de>> {
        unsafe { Some(self.table.get(3)?.deref_unchecked()) }
    }

    pub fn config_values(&self) -> ::core::option::Option<&::fidl_next_fuchsia_mem::WireData<'de>> {
        unsafe { Some(self.table.get(4)?.deref_unchecked()) }
    }

    pub fn resolution_context(&self) -> ::core::option::Option<&crate::WireContext<'de>> {
        unsafe { Some(self.table.get(5)?.deref_unchecked()) }
    }

    pub fn abi_revision(&self) -> ::core::option::Option<&::fidl_next::WireU64> {
        unsafe { Some(self.table.get(6)?.deref_unchecked()) }
    }
}

impl<'de> ::core::fmt::Debug for WireComponent<'de> {
    fn fmt(
        &self,
        f: &mut ::core::fmt::Formatter<'_>,
    ) -> ::core::result::Result<(), ::core::fmt::Error> {
        f.debug_struct("Component")
            .field("url", &self.url())
            .field("decl", &self.decl())
            .field("package", &self.package())
            .field("config_values", &self.config_values())
            .field("resolution_context", &self.resolution_context())
            .field("abi_revision", &self.abi_revision())
            .finish()
    }
}

#[derive(PartialEq, Clone, Debug)]
pub struct ResolverResolveRequest {
    pub component_url: ::std::string::String,
}

impl ::fidl_next::Encodable for ResolverResolveRequest {
    type Encoded = WireResolverResolveRequest<'static>;
}

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

            } = out_;
        }

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

        Ok(())
    }
}

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

                component_url,

            } = out_;
        }

        ::fidl_next::EncodeRef::encode_ref(&self.component_url, encoder_, component_url)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ResolverResolveRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ResolverResolveRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: ::core::option::Option<Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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 ResolverResolveRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ResolverResolveRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: ::core::option::Option<&Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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<'de> ::fidl_next::FromWire<WireResolverResolveRequest<'de>> for ResolverResolveRequest {
    #[inline]
    fn from_wire(wire: WireResolverResolveRequest<'de>) -> Self {
        Self { component_url: ::fidl_next::FromWire::from_wire(wire.component_url) }
    }
}

impl<'de> ::fidl_next::IntoNatural for WireResolverResolveRequest<'de> {
    type Natural = ResolverResolveRequest;
}

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

/// The wire type corresponding to [`ResolverResolveRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireResolverResolveRequest<'de> {
    pub component_url: ::fidl_next::WireString<'de>,
}
static_assertions::const_assert_eq!(std::mem::size_of::<WireResolverResolveRequest<'_>>(), 16);
static_assertions::const_assert_eq!(std::mem::align_of::<WireResolverResolveRequest<'_>>(), 8);

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

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

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

                component_url,

            } = &mut *out_;
        }

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

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

                mut component_url,

            } = slot_;
        }

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

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

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

        Ok(())
    }
}

#[derive(PartialEq, Clone, Debug)]
pub struct ResolverResolveWithContextRequest {
    pub component_url: ::std::string::String,

    pub context: crate::Context,
}

impl ::fidl_next::Encodable for ResolverResolveWithContextRequest {
    type Encoded = WireResolverResolveWithContextRequest<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ResolverResolveWithContextRequest
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    ___E: ::fidl_next::Encoder,
{
    #[inline]
    fn encode(
        self,
        encoder_: &mut ___E,
        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                component_url,
                context,

            } = out_;
        }

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

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

        Ok(())
    }
}

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

                component_url,
                context,

            } = out_;
        }

        ::fidl_next::EncodeRef::encode_ref(&self.component_url, encoder_, component_url)?;

        ::fidl_next::EncodeRef::encode_ref(&self.context, encoder_, context)?;

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ResolverResolveWithContextRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ResolverResolveWithContextRequest: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: ::core::option::Option<Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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 ResolverResolveWithContextRequest
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ResolverResolveWithContextRequest: ::fidl_next::EncodeRef<___E>,
{
    #[inline]
    fn encode_option_ref(
        this: ::core::option::Option<&Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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<'de> ::fidl_next::FromWire<WireResolverResolveWithContextRequest<'de>>
    for ResolverResolveWithContextRequest
{
    #[inline]
    fn from_wire(wire: WireResolverResolveWithContextRequest<'de>) -> Self {
        Self {
            component_url: ::fidl_next::FromWire::from_wire(wire.component_url),

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

impl<'de> ::fidl_next::IntoNatural for WireResolverResolveWithContextRequest<'de> {
    type Natural = ResolverResolveWithContextRequest;
}

impl<'de> ::fidl_next::FromWireRef<WireResolverResolveWithContextRequest<'de>>
    for ResolverResolveWithContextRequest
{
    #[inline]
    fn from_wire_ref(wire: &WireResolverResolveWithContextRequest<'de>) -> Self {
        Self {
            component_url: ::fidl_next::FromWireRef::from_wire_ref(&wire.component_url),

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

/// The wire type corresponding to [`ResolverResolveWithContextRequest`].
#[derive(Debug)]
#[repr(C)]
pub struct WireResolverResolveWithContextRequest<'de> {
    pub component_url: ::fidl_next::WireString<'de>,

    pub context: crate::WireContext<'de>,
}
static_assertions::const_assert_eq!(
    std::mem::size_of::<WireResolverResolveWithContextRequest<'_>>(),
    32
);
static_assertions::const_assert_eq!(
    std::mem::align_of::<WireResolverResolveWithContextRequest<'_>>(),
    8
);

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

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

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

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

                component_url,
                context,

            } = &mut *out_;
        }

        ::fidl_next::Wire::zero_padding(component_url);

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

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

                mut component_url,
                mut context,

            } = slot_;
        }

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

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

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

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

        Ok(())
    }
}

#[doc = " The possible error conditions returned by ComponentResolver.\n"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u32)]
pub enum ResolverError {
    Internal = 1,
    Io = 2,
    InvalidArgs = 3,
    NotSupported = 4,
    ManifestNotFound = 5,
    PackageNotFound = 6,
    NoSpace = 7,
    ResourceUnavailable = 8,
    InvalidManifest = 9,
    ConfigValuesNotFound = 10,
    AbiRevisionNotFound = 11,
    InvalidAbiRevision = 12,
}

impl ::fidl_next::Encodable for ResolverError {
    type Encoded = WireResolverError;
}
impl ::core::convert::TryFrom<u32> for ResolverError {
    type Error = ::fidl_next::UnknownStrictEnumMemberError;
    fn try_from(
        value: u32,
    ) -> ::core::result::Result<Self, ::fidl_next::UnknownStrictEnumMemberError> {
        match value {
            1 => Ok(Self::Internal),
            2 => Ok(Self::Io),
            3 => Ok(Self::InvalidArgs),
            4 => Ok(Self::NotSupported),
            5 => Ok(Self::ManifestNotFound),
            6 => Ok(Self::PackageNotFound),
            7 => Ok(Self::NoSpace),
            8 => Ok(Self::ResourceUnavailable),
            9 => Ok(Self::InvalidManifest),
            10 => Ok(Self::ConfigValuesNotFound),
            11 => Ok(Self::AbiRevisionNotFound),
            12 => Ok(Self::InvalidAbiRevision),

            _ => Err(::fidl_next::UnknownStrictEnumMemberError::new(value.into())),
        }
    }
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ResolverError
where
    ___E: ?Sized,
{
    #[inline]
    fn encode(
        self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::EncodeRef::encode_ref(&self, encoder, out)
    }
}

unsafe impl<___E> ::fidl_next::EncodeRef<___E> for ResolverError
where
    ___E: ?Sized,
{
    #[inline]
    fn encode_ref(
        &self,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge!(let WireResolverError { value } = out);
        let _ = value.write(::fidl_next::WireU32::from(match *self {
            Self::Internal => 1,

            Self::Io => 2,

            Self::InvalidArgs => 3,

            Self::NotSupported => 4,

            Self::ManifestNotFound => 5,

            Self::PackageNotFound => 6,

            Self::NoSpace => 7,

            Self::ResourceUnavailable => 8,

            Self::InvalidManifest => 9,

            Self::ConfigValuesNotFound => 10,

            Self::AbiRevisionNotFound => 11,

            Self::InvalidAbiRevision => 12,
        }));

        Ok(())
    }
}

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

            2 => Self::Io,

            3 => Self::InvalidArgs,

            4 => Self::NotSupported,

            5 => Self::ManifestNotFound,

            6 => Self::PackageNotFound,

            7 => Self::NoSpace,

            8 => Self::ResourceUnavailable,

            9 => Self::InvalidManifest,

            10 => Self::ConfigValuesNotFound,

            11 => Self::AbiRevisionNotFound,

            12 => Self::InvalidAbiRevision,

            _ => unsafe { ::core::hint::unreachable_unchecked() },
        }
    }
}

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

impl ::fidl_next::IntoNatural for WireResolverError {
    type Natural = ResolverError;
}

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

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

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

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

impl WireResolverError {
    pub const INTERNAL: WireResolverError = WireResolverError { value: ::fidl_next::WireU32(1) };

    pub const IO: WireResolverError = WireResolverError { value: ::fidl_next::WireU32(2) };

    pub const INVALID_ARGS: WireResolverError =
        WireResolverError { value: ::fidl_next::WireU32(3) };

    pub const NOT_SUPPORTED: WireResolverError =
        WireResolverError { value: ::fidl_next::WireU32(4) };

    pub const MANIFEST_NOT_FOUND: WireResolverError =
        WireResolverError { value: ::fidl_next::WireU32(5) };

    pub const PACKAGE_NOT_FOUND: WireResolverError =
        WireResolverError { value: ::fidl_next::WireU32(6) };

    pub const NO_SPACE: WireResolverError = WireResolverError { value: ::fidl_next::WireU32(7) };

    pub const RESOURCE_UNAVAILABLE: WireResolverError =
        WireResolverError { value: ::fidl_next::WireU32(8) };

    pub const INVALID_MANIFEST: WireResolverError =
        WireResolverError { value: ::fidl_next::WireU32(9) };

    pub const CONFIG_VALUES_NOT_FOUND: WireResolverError =
        WireResolverError { value: ::fidl_next::WireU32(10) };

    pub const ABI_REVISION_NOT_FOUND: WireResolverError =
        WireResolverError { value: ::fidl_next::WireU32(11) };

    pub const INVALID_ABI_REVISION: WireResolverError =
        WireResolverError { value: ::fidl_next::WireU32(12) };
}

unsafe impl<___D> ::fidl_next::Decode<___D> for WireResolverError
where
    ___D: ?Sized,
{
    fn decode(
        slot: ::fidl_next::Slot<'_, Self>,
        _: &mut ___D,
    ) -> ::core::result::Result<(), ::fidl_next::DecodeError> {
        ::fidl_next::munge!(let Self { value } = slot);

        match u32::from(*value) {
            1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 => (),
            unknown => return Err(::fidl_next::DecodeError::InvalidEnumOrdinal(unknown as i128)),
        }

        Ok(())
    }
}

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

            ResolverError::Io => WireResolverError::IO,

            ResolverError::InvalidArgs => WireResolverError::INVALID_ARGS,

            ResolverError::NotSupported => WireResolverError::NOT_SUPPORTED,

            ResolverError::ManifestNotFound => WireResolverError::MANIFEST_NOT_FOUND,

            ResolverError::PackageNotFound => WireResolverError::PACKAGE_NOT_FOUND,

            ResolverError::NoSpace => WireResolverError::NO_SPACE,

            ResolverError::ResourceUnavailable => WireResolverError::RESOURCE_UNAVAILABLE,

            ResolverError::InvalidManifest => WireResolverError::INVALID_MANIFEST,

            ResolverError::ConfigValuesNotFound => WireResolverError::CONFIG_VALUES_NOT_FOUND,

            ResolverError::AbiRevisionNotFound => WireResolverError::ABI_REVISION_NOT_FOUND,

            ResolverError::InvalidAbiRevision => WireResolverError::INVALID_ABI_REVISION,
        }
    }
}

#[derive(PartialEq, Debug)]
pub struct ResolverResolveResponse {
    pub component: crate::Component,
}

impl ::fidl_next::Encodable for ResolverResolveResponse {
    type Encoded = WireResolverResolveResponse<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ResolverResolveResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    ___E: ::fidl_next::Encoder,
    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        self,
        encoder_: &mut ___E,
        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                component,

            } = out_;
        }

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

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ResolverResolveResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ResolverResolveResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: ::core::option::Option<Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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<'de> ::fidl_next::FromWire<WireResolverResolveResponse<'de>> for ResolverResolveResponse {
    #[inline]
    fn from_wire(wire: WireResolverResolveResponse<'de>) -> Self {
        Self { component: ::fidl_next::FromWire::from_wire(wire.component) }
    }
}

impl<'de> ::fidl_next::IntoNatural for WireResolverResolveResponse<'de> {
    type Natural = ResolverResolveResponse;
}

/// The wire type corresponding to [`ResolverResolveResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireResolverResolveResponse<'de> {
    pub component: crate::WireComponent<'de>,
}
static_assertions::const_assert_eq!(std::mem::size_of::<WireResolverResolveResponse<'_>>(), 16);
static_assertions::const_assert_eq!(std::mem::align_of::<WireResolverResolveResponse<'_>>(), 8);

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

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

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

                component,

            } = &mut *out_;
        }

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

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

                mut component,

            } = slot_;
        }

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

        Ok(())
    }
}

#[derive(PartialEq, Debug)]
pub struct ResolverResolveWithContextResponse {
    pub component: crate::Component,
}

impl ::fidl_next::Encodable for ResolverResolveWithContextResponse {
    type Encoded = WireResolverResolveWithContextResponse<'static>;
}

unsafe impl<___E> ::fidl_next::Encode<___E> for ResolverResolveWithContextResponse
where
    ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
    ___E: ::fidl_next::Encoder,
    ___E: ::fidl_next::fuchsia::HandleEncoder,
{
    #[inline]
    fn encode(
        self,
        encoder_: &mut ___E,
        out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
    ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
        ::fidl_next::munge! {
            let Self::Encoded {
                component,

            } = out_;
        }

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

        Ok(())
    }
}

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

unsafe impl<___E> ::fidl_next::EncodeOption<___E> for ResolverResolveWithContextResponse
where
    ___E: ::fidl_next::Encoder + ?Sized,
    ResolverResolveWithContextResponse: ::fidl_next::Encode<___E>,
{
    #[inline]
    fn encode_option(
        this: ::core::option::Option<Self>,
        encoder: &mut ___E,
        out: &mut ::core::mem::MaybeUninit<Self::EncodedOption>,
    ) -> ::core::result::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<'de> ::fidl_next::FromWire<WireResolverResolveWithContextResponse<'de>>
    for ResolverResolveWithContextResponse
{
    #[inline]
    fn from_wire(wire: WireResolverResolveWithContextResponse<'de>) -> Self {
        Self { component: ::fidl_next::FromWire::from_wire(wire.component) }
    }
}

impl<'de> ::fidl_next::IntoNatural for WireResolverResolveWithContextResponse<'de> {
    type Natural = ResolverResolveWithContextResponse;
}

/// The wire type corresponding to [`ResolverResolveWithContextResponse`].
#[derive(Debug)]
#[repr(C)]
pub struct WireResolverResolveWithContextResponse<'de> {
    pub component: crate::WireComponent<'de>,
}
static_assertions::const_assert_eq!(
    std::mem::size_of::<WireResolverResolveWithContextResponse<'_>>(),
    16
);
static_assertions::const_assert_eq!(
    std::mem::align_of::<WireResolverResolveWithContextResponse<'_>>(),
    8
);

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

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

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

                component,

            } = &mut *out_;
        }

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

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

                mut component,

            } = slot_;
        }

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

        Ok(())
    }
}

/// The type corresponding to the Resolver protocol.
#[doc = " An interface for resolving a URL to a component.\n\n This interface is implemented by components that provide support\n for loading components with a particular URL scheme.   For example,\n the Fuchsia package component resolver exposes a service with this\n interface to resolve component URLs using the \"fuchsia-pkg://\" scheme.\n\n To use a resolver to resolve URLs within your realm, register it\n in your realm\'s manifest.\n\n Note: The component manager is the only intended direct client of this\n interface.\n"]
#[derive(PartialEq, Debug)]
pub struct Resolver;

impl ::fidl_next::Discoverable for Resolver {
    const PROTOCOL_NAME: &'static str = "fuchsia.component.resolution.Resolver";
}

pub mod resolver {
    pub mod prelude {
        pub use crate::{Resolver, ResolverClientHandler, ResolverServerHandler, resolver};

        pub use crate::ResolverError;

        pub use crate::ResolverResolveRequest;

        pub use crate::ResolverResolveWithContextRequest;

        pub use crate::ResolverResolveWithContextResponse;

        pub use crate::ResolverResolveResponse;
    }

    pub struct Resolve;

    impl ::fidl_next::Method for Resolve {
        const ORDINAL: u64 = 6339326548187935461;

        type Protocol = crate::Resolver;

        type Request = crate::WireResolverResolveRequest<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            crate::WireResolverResolveResponse<'static>,
            crate::WireResolverError,
        >;
    }

    pub struct ResolveWithContext;

    impl ::fidl_next::Method for ResolveWithContext {
        const ORDINAL: u64 = 5576776708309151933;

        type Protocol = crate::Resolver;

        type Request = crate::WireResolverResolveWithContextRequest<'static>;

        type Response = ::fidl_next::WireResult<
            'static,
            crate::WireResolverResolveWithContextResponse<'static>,
            crate::WireResolverError,
        >;
    }

    mod ___detail {

        pub struct Resolve<T0> {
            component_url: T0,
        }

        impl<T0> ::fidl_next::Encodable for Resolve<T0>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
        {
            type Encoded = crate::WireResolverResolveRequest<'static>;
        }

        unsafe impl<___E, T0> ::fidl_next::Encode<___E> for Resolve<T0>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
            ___E: ::fidl_next::Encoder,
            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
        {
            #[inline]
            fn encode(
                self,
                encoder_: &mut ___E,
                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
                ::fidl_next::munge! {
                    let Self::Encoded {
                        component_url,

                    } = out_;
                }

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

                Ok(())
            }
        }

        pub struct ResolveWithContext<T0, T1> {
            component_url: T0,

            context: T1,
        }

        impl<T0, T1> ::fidl_next::Encodable for ResolveWithContext<T0, T1>
        where
            T0: ::fidl_next::Encodable<Encoded = ::fidl_next::WireString<'static>>,
            T1: ::fidl_next::Encodable<Encoded = crate::WireContext<'static>>,
        {
            type Encoded = crate::WireResolverResolveWithContextRequest<'static>;
        }

        unsafe impl<___E, T0, T1> ::fidl_next::Encode<___E> for ResolveWithContext<T0, T1>
        where
            ___E: ::fidl_next::encoder::InternalHandleEncoder + ?Sized,
            ___E: ::fidl_next::Encoder,
            T0: ::fidl_next::Encode<___E, Encoded = ::fidl_next::WireString<'static>>,
            T1: ::fidl_next::Encode<___E, Encoded = crate::WireContext<'static>>,
        {
            #[inline]
            fn encode(
                self,
                encoder_: &mut ___E,
                out_: &mut ::core::mem::MaybeUninit<Self::Encoded>,
            ) -> ::core::result::Result<(), ::fidl_next::EncodeError> {
                ::fidl_next::munge! {
                    let Self::Encoded {
                        component_url,
                        context,

                    } = out_;
                }

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

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

                Ok(())
            }
        }

        unsafe impl<___T> ::fidl_next::Protocol<___T> for crate::Resolver
        where
            ___T: ::fidl_next::Transport,
        {
            type Client = ResolverClient<___T>;
            type Server = ResolverServer<___T>;
        }

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

        impl<___T> ResolverClient<___T>
        where
            ___T: ::fidl_next::Transport,
        {
            #[doc = " Resolves a component with the given absolute URL.\n\n `component_url` is the unescaped URL of the component to resolve.\n\n If successful, returns information about the component\n that was resolved.\n\n On failure, returns a `ResolverError` error.\n"]
            pub fn resolve(
                &self,

                component_url: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireString<'static>,
                >,
            ) -> ::fidl_next::TwoWayFuture<'_, super::Resolve, ___T>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.resolve_with(Resolve { component_url })
            }

            #[doc = " Resolves a component with the given absolute URL.\n\n `component_url` is the unescaped URL of the component to resolve.\n\n If successful, returns information about the component\n that was resolved.\n\n On failure, returns a `ResolverError` error.\n"]
            pub fn resolve_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::TwoWayFuture<'_, super::Resolve, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <___T as ::fidl_next::Transport>::SendBuffer,
                        Encoded = crate::WireResolverResolveRequest<'static>,
                    >,
            {
                ::fidl_next::TwoWayFuture::from_untyped(
                    self.client.send_two_way(6339326548187935461, request),
                )
            }

            #[doc = " Resolves a component with the absolute or relative URL. If relative, the\n component will be resolved relative to the supplied `context`.\n\n `component_url` is the unescaped URL of the component to resolve, the\n format of which can be either:\n\n   * a fully-qualified absolute component URL; or\n   * a subpackaged-component reference, prefixed by a URI relative\n     path to its containing subpackage (for example,\n     `child_package#meta/some_component.cm`)\n\n `context` is the `resolution_context` of a previously-resolved\n `Component`, providing the context for resoving a relative URL.\n"]
            pub fn resolve_with_context(
                &self,

                component_url: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = ::fidl_next::WireString<'static>,
                >,

                context: impl ::fidl_next::Encode<
                    <___T as ::fidl_next::Transport>::SendBuffer,
                    Encoded = crate::WireContext<'static>,
                >,
            ) -> ::fidl_next::TwoWayFuture<'_, super::ResolveWithContext, ___T>
            where
                <___T as ::fidl_next::Transport>::SendBuffer:
                    ::fidl_next::encoder::InternalHandleEncoder,
                <___T as ::fidl_next::Transport>::SendBuffer: ::fidl_next::Encoder,
            {
                self.resolve_with_context_with(ResolveWithContext { component_url, context })
            }

            #[doc = " Resolves a component with the absolute or relative URL. If relative, the\n component will be resolved relative to the supplied `context`.\n\n `component_url` is the unescaped URL of the component to resolve, the\n format of which can be either:\n\n   * a fully-qualified absolute component URL; or\n   * a subpackaged-component reference, prefixed by a URI relative\n     path to its containing subpackage (for example,\n     `child_package#meta/some_component.cm`)\n\n `context` is the `resolution_context` of a previously-resolved\n `Component`, providing the context for resoving a relative URL.\n"]
            pub fn resolve_with_context_with<___R>(
                &self,
                request: ___R,
            ) -> ::fidl_next::TwoWayFuture<'_, super::ResolveWithContext, ___T>
            where
                ___R: ::fidl_next::Encode<
                        <___T as ::fidl_next::Transport>::SendBuffer,
                        Encoded = crate::WireResolverResolveWithContextRequest<'static>,
                    >,
            {
                ::fidl_next::TwoWayFuture::from_untyped(
                    self.client.send_two_way(5576776708309151933, request),
                )
            }
        }

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

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

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

impl<___H, ___T> ::fidl_next::DispatchClientMessage<___H, ___T> for Resolver
where
    ___H: ResolverClientHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
    <resolver::Resolve as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <resolver::ResolveWithContext as ::fidl_next::Method>::Response:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_event(
        handler: &mut ___H,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) -> ::core::result::Result<(), ::fidl_next::ProtocolError<___T::Error>> {
        match ordinal {
            ordinal => handler.on_unknown_interaction(ordinal).await,
        }
    }
}

/// A server handler for the Resolver protocol.
///
/// See [`Resolver`] for more details.
pub trait ResolverServerHandler<
    #[cfg(not(feature = "fuchsia"))] ___T: ::fidl_next::Transport,
    #[cfg(feature = "fuchsia")] ___T: ::fidl_next::Transport = ::fidl_next::fuchsia::zx::Channel,
>
{
    #[doc = " Resolves a component with the given absolute URL.\n\n `component_url` is the unescaped URL of the component to resolve.\n\n If successful, returns information about the component\n that was resolved.\n\n On failure, returns a `ResolverError` error.\n"]
    fn resolve(
        &mut self,

        request: ::fidl_next::Request<resolver::Resolve, ___T>,

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

    #[doc = " Resolves a component with the absolute or relative URL. If relative, the\n component will be resolved relative to the supplied `context`.\n\n `component_url` is the unescaped URL of the component to resolve, the\n format of which can be either:\n\n   * a fully-qualified absolute component URL; or\n   * a subpackaged-component reference, prefixed by a URI relative\n     path to its containing subpackage (for example,\n     `child_package#meta/some_component.cm`)\n\n `context` is the `resolution_context` of a previously-resolved\n `Component`, providing the context for resoving a relative URL.\n"]
    fn resolve_with_context(
        &mut self,

        request: ::fidl_next::Request<resolver::ResolveWithContext, ___T>,

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

    fn on_unknown_interaction(
        &mut self,
        ordinal: u64,
    ) -> impl ::core::future::Future<
        Output = ::core::result::Result<
            (),
            ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
        >,
    > + ::core::marker::Send {
        ::core::future::ready(Err(::fidl_next::ProtocolError::InvalidOrdinal(ordinal)))
    }
}

impl<___H, ___T> ::fidl_next::DispatchServerMessage<___H, ___T> for Resolver
where
    ___H: ResolverServerHandler<___T> + ::core::marker::Send,
    ___T: ::fidl_next::Transport,
    <resolver::Resolve as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
    <resolver::ResolveWithContext as ::fidl_next::Method>::Request:
        ::fidl_next::Decode<<___T as ::fidl_next::Transport>::RecvBuffer>,
{
    async fn on_one_way(
        handler: &mut ___H,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match ordinal {
            ordinal => handler.on_unknown_interaction(ordinal).await,
        }
    }

    async fn on_two_way(
        handler: &mut ___H,
        ordinal: u64,
        buffer: ___T::RecvBuffer,
        responder: ::fidl_next::protocol::Responder<___T>,
    ) -> ::core::result::Result<
        (),
        ::fidl_next::ProtocolError<<___T as ::fidl_next::Transport>::Error>,
    > {
        match ordinal {
            6339326548187935461 => {
                let responder = ::fidl_next::Responder::from_untyped(responder);

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => {
                        handler.resolve(decoded, responder).await;
                        Ok(())
                    }
                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                        ordinal: 6339326548187935461,
                        error,
                    }),
                }
            }

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

                match ::fidl_next::DecoderExt::decode(buffer) {
                    Ok(decoded) => {
                        handler.resolve_with_context(decoded, responder).await;
                        Ok(())
                    }
                    Err(error) => Err(::fidl_next::ProtocolError::InvalidMessage {
                        ordinal: 5576776708309151933,
                        error,
                    }),
                }
            }

            ordinal => handler.on_unknown_interaction(ordinal).await,
        }
    }
}

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

    impl ::fidl_next::CompatFrom<crate::Context> for ::fidl_fuchsia_component_resolution::Context {
        #[inline]
        fn compat_from(value: crate::Context) -> Self {
            Self { bytes: ::fidl_next::CompatFrom::compat_from(value.bytes) }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_resolution::Context> for crate::Context {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_component_resolution::Context) -> Self {
            Self { bytes: ::fidl_next::CompatFrom::compat_from(value.bytes) }
        }
    }

    impl ::fidl_next::CompatFrom<crate::Package> for ::fidl_fuchsia_component_resolution::Package {
        fn compat_from(value: crate::Package) -> Self {
            Self {
                url: ::fidl_next::CompatFrom::compat_from(value.url),

                directory: ::fidl_next::CompatFrom::compat_from(value.directory),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_resolution::Package> for crate::Package {
        fn compat_from(value: ::fidl_fuchsia_component_resolution::Package) -> Self {
            Self {
                url: ::fidl_next::CompatFrom::compat_from(value.url),

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

    impl ::fidl_next::CompatFrom<crate::Component> for ::fidl_fuchsia_component_resolution::Component {
        fn compat_from(value: crate::Component) -> Self {
            Self {
                url: ::fidl_next::CompatFrom::compat_from(value.url),

                decl: ::fidl_next::CompatFrom::compat_from(value.decl),

                package: ::fidl_next::CompatFrom::compat_from(value.package),

                config_values: ::fidl_next::CompatFrom::compat_from(value.config_values),

                resolution_context: ::fidl_next::CompatFrom::compat_from(value.resolution_context),

                abi_revision: ::fidl_next::CompatFrom::compat_from(value.abi_revision),

                __source_breaking: ::fidl::marker::SourceBreaking,
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_resolution::Component> for crate::Component {
        fn compat_from(value: ::fidl_fuchsia_component_resolution::Component) -> Self {
            Self {
                url: ::fidl_next::CompatFrom::compat_from(value.url),

                decl: ::fidl_next::CompatFrom::compat_from(value.decl),

                package: ::fidl_next::CompatFrom::compat_from(value.package),

                config_values: ::fidl_next::CompatFrom::compat_from(value.config_values),

                resolution_context: ::fidl_next::CompatFrom::compat_from(value.resolution_context),

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

    impl ::fidl_next::CompatFrom<crate::ResolverResolveRequest>
        for ::fidl_fuchsia_component_resolution::ResolverResolveRequest
    {
        #[inline]
        fn compat_from(value: crate::ResolverResolveRequest) -> Self {
            Self { component_url: ::fidl_next::CompatFrom::compat_from(value.component_url) }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_resolution::ResolverResolveRequest>
        for crate::ResolverResolveRequest
    {
        #[inline]
        fn compat_from(value: ::fidl_fuchsia_component_resolution::ResolverResolveRequest) -> Self {
            Self { component_url: ::fidl_next::CompatFrom::compat_from(value.component_url) }
        }
    }

    impl ::fidl_next::CompatFrom<crate::ResolverResolveWithContextRequest>
        for ::fidl_fuchsia_component_resolution::ResolverResolveWithContextRequest
    {
        #[inline]
        fn compat_from(value: crate::ResolverResolveWithContextRequest) -> Self {
            Self {
                component_url: ::fidl_next::CompatFrom::compat_from(value.component_url),

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

    impl
        ::fidl_next::CompatFrom<
            ::fidl_fuchsia_component_resolution::ResolverResolveWithContextRequest,
        > for crate::ResolverResolveWithContextRequest
    {
        #[inline]
        fn compat_from(
            value: ::fidl_fuchsia_component_resolution::ResolverResolveWithContextRequest,
        ) -> Self {
            Self {
                component_url: ::fidl_next::CompatFrom::compat_from(value.component_url),

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

    impl ::fidl_next::CompatFrom<crate::ResolverError>
        for ::fidl_fuchsia_component_resolution::ResolverError
    {
        fn compat_from(value: crate::ResolverError) -> Self {
            match value {
                crate::ResolverError::Internal => Self::Internal,

                crate::ResolverError::Io => Self::Io,

                crate::ResolverError::InvalidArgs => Self::InvalidArgs,

                crate::ResolverError::NotSupported => Self::NotSupported,

                crate::ResolverError::ManifestNotFound => Self::ManifestNotFound,

                crate::ResolverError::PackageNotFound => Self::PackageNotFound,

                crate::ResolverError::NoSpace => Self::NoSpace,

                crate::ResolverError::ResourceUnavailable => Self::ResourceUnavailable,

                crate::ResolverError::InvalidManifest => Self::InvalidManifest,

                crate::ResolverError::ConfigValuesNotFound => Self::ConfigValuesNotFound,

                crate::ResolverError::AbiRevisionNotFound => Self::AbiRevisionNotFound,

                crate::ResolverError::InvalidAbiRevision => Self::InvalidAbiRevision,
            }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_resolution::ResolverError>
        for crate::ResolverError
    {
        fn compat_from(value: ::fidl_fuchsia_component_resolution::ResolverError) -> Self {
            match value {
                ::fidl_fuchsia_component_resolution::ResolverError::Internal => Self::Internal,

                ::fidl_fuchsia_component_resolution::ResolverError::Io => Self::Io,

                ::fidl_fuchsia_component_resolution::ResolverError::InvalidArgs => {
                    Self::InvalidArgs
                }

                ::fidl_fuchsia_component_resolution::ResolverError::NotSupported => {
                    Self::NotSupported
                }

                ::fidl_fuchsia_component_resolution::ResolverError::ManifestNotFound => {
                    Self::ManifestNotFound
                }

                ::fidl_fuchsia_component_resolution::ResolverError::PackageNotFound => {
                    Self::PackageNotFound
                }

                ::fidl_fuchsia_component_resolution::ResolverError::NoSpace => Self::NoSpace,

                ::fidl_fuchsia_component_resolution::ResolverError::ResourceUnavailable => {
                    Self::ResourceUnavailable
                }

                ::fidl_fuchsia_component_resolution::ResolverError::InvalidManifest => {
                    Self::InvalidManifest
                }

                ::fidl_fuchsia_component_resolution::ResolverError::ConfigValuesNotFound => {
                    Self::ConfigValuesNotFound
                }

                ::fidl_fuchsia_component_resolution::ResolverError::AbiRevisionNotFound => {
                    Self::AbiRevisionNotFound
                }

                ::fidl_fuchsia_component_resolution::ResolverError::InvalidAbiRevision => {
                    Self::InvalidAbiRevision
                }
            }
        }
    }

    impl ::fidl_next::CompatFrom<crate::ResolverResolveResponse>
        for ::fidl_fuchsia_component_resolution::ResolverResolveResponse
    {
        #[inline]
        fn compat_from(value: crate::ResolverResolveResponse) -> Self {
            Self { component: ::fidl_next::CompatFrom::compat_from(value.component) }
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_resolution::ResolverResolveResponse>
        for crate::ResolverResolveResponse
    {
        #[inline]
        fn compat_from(
            value: ::fidl_fuchsia_component_resolution::ResolverResolveResponse,
        ) -> Self {
            Self { component: ::fidl_next::CompatFrom::compat_from(value.component) }
        }
    }

    impl ::fidl_next::CompatFrom<crate::ResolverResolveWithContextResponse>
        for ::fidl_fuchsia_component_resolution::ResolverResolveWithContextResponse
    {
        #[inline]
        fn compat_from(value: crate::ResolverResolveWithContextResponse) -> Self {
            Self { component: ::fidl_next::CompatFrom::compat_from(value.component) }
        }
    }

    impl
        ::fidl_next::CompatFrom<
            ::fidl_fuchsia_component_resolution::ResolverResolveWithContextResponse,
        > for crate::ResolverResolveWithContextResponse
    {
        #[inline]
        fn compat_from(
            value: ::fidl_fuchsia_component_resolution::ResolverResolveWithContextResponse,
        ) -> Self {
            Self { component: ::fidl_next::CompatFrom::compat_from(value.component) }
        }
    }

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

    impl ::fidl_next::CompatFrom<crate::Resolver>
        for ::fidl_fuchsia_component_resolution::ResolverMarker
    {
        fn compat_from(_: crate::Resolver) -> Self {
            Self
        }
    }

    impl ::fidl_next::CompatFrom<::fidl_fuchsia_component_resolution::ResolverMarker>
        for crate::Resolver
    {
        fn compat_from(_: ::fidl_fuchsia_component_resolution::ResolverMarker) -> Self {
            Self
        }
    }

    #[cfg(target_os = "fuchsia")]

    impl ::fidl_next::ClientCompatFrom<::fidl_fuchsia_component_resolution::ResolverProxy>
        for crate::Resolver
    {
        fn client_compat_from(
            proxy: ::fidl_fuchsia_component_resolution::ResolverProxy,
        ) -> ::fidl_next::ClientDispatcher<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::ClientDispatcher::new(client_end)
        }
    }
}