// Generated by `wit-bindgen` 0.51.0. DO NOT EDIT!
// Options used:
//   * with "wasi:cli/stdin@0.3.0-rc-2026-01-06" = "crate::cli::stdin"
//   * with "wasi:cli/stdout@0.3.0-rc-2026-01-06" = "crate::cli::stdout"
//   * with "wasi:cli/stderr@0.3.0-rc-2026-01-06" = "crate::cli::stderr"
//   * with "wasi:cli/types@0.3.0-rc-2026-01-06" = "crate::cli::types"
//   * with "wasi:clocks/monotonic-clock@0.3.0-rc-2026-01-06" = "crate::clocks::monotonic_clock"
//   * with "wasi:clocks/system-clock@0.3.0-rc-2026-01-06" = "crate::clocks::system_clock"
//   * with "wasi:clocks/types@0.3.0-rc-2026-01-06" = "crate::clocks::types"
//   * with "wasi:random/random@0.3.0-rc-2026-01-06" = "crate::random::random"
//   * with "wasi:random/insecure@0.3.0-rc-2026-01-06" = "crate::random::insecure"
//   * with "wasi:random/insecure-seed@0.3.0-rc-2026-01-06" = "crate::random::insecure_seed"
//   * type_section_suffix: "rust-wasip3-0.4.0+wasi-0.3.0-rc-2026-01-06-from-crates-io-service-world"
//   * default-bindings-module: "$crate"
//   * export-macro-name: _export_service
//   * pub-export-macro
#[allow(unfulfilled_lint_expectations, unused_imports)]
use crate::cli::types as __with_name0;
#[allow(unfulfilled_lint_expectations, unused_imports)]
use crate::cli::stdout as __with_name1;
#[allow(unfulfilled_lint_expectations, unused_imports)]
use crate::cli::stderr as __with_name2;
#[allow(unfulfilled_lint_expectations, unused_imports)]
use crate::cli::stdin as __with_name3;
#[allow(unfulfilled_lint_expectations, unused_imports)]
use crate::clocks::types as __with_name4;
#[allow(unfulfilled_lint_expectations, unused_imports)]
use crate::clocks::monotonic_clock as __with_name5;
#[allow(unfulfilled_lint_expectations, unused_imports)]
use crate::clocks::system_clock as __with_name6;
#[allow(unfulfilled_lint_expectations, unused_imports)]
use crate::random::random as __with_name7;
#[allow(unfulfilled_lint_expectations, unused_imports)]
use crate::random::insecure as __with_name8;
#[allow(unfulfilled_lint_expectations, unused_imports)]
use crate::random::insecure_seed as __with_name9;
#[rustfmt::skip]
#[allow(dead_code, clippy::all)]
pub mod wasi {
    pub mod http {
        /// This interface defines all of the types and methods for implementing HTTP
        /// Requests and Responses, as well as their headers, trailers, and bodies.
        #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)]
        pub mod types {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            use super::super::super::_rt;
            pub type Duration = super::super::super::__with_name4::Duration;
            /// This type corresponds to HTTP standard Methods.
            #[derive(Clone)]
            pub enum Method {
                Get,
                Head,
                Post,
                Put,
                Delete,
                Connect,
                Options,
                Trace,
                Patch,
                Other(_rt::String),
            }
            impl ::core::fmt::Debug for Method {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        Method::Get => f.debug_tuple("Method::Get").finish(),
                        Method::Head => f.debug_tuple("Method::Head").finish(),
                        Method::Post => f.debug_tuple("Method::Post").finish(),
                        Method::Put => f.debug_tuple("Method::Put").finish(),
                        Method::Delete => f.debug_tuple("Method::Delete").finish(),
                        Method::Connect => f.debug_tuple("Method::Connect").finish(),
                        Method::Options => f.debug_tuple("Method::Options").finish(),
                        Method::Trace => f.debug_tuple("Method::Trace").finish(),
                        Method::Patch => f.debug_tuple("Method::Patch").finish(),
                        Method::Other(e) => {
                            f.debug_tuple("Method::Other").field(e).finish()
                        }
                    }
                }
            }
            /// This type corresponds to HTTP standard Related Schemes.
            #[derive(Clone)]
            pub enum Scheme {
                Http,
                Https,
                Other(_rt::String),
            }
            impl ::core::fmt::Debug for Scheme {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        Scheme::Http => f.debug_tuple("Scheme::Http").finish(),
                        Scheme::Https => f.debug_tuple("Scheme::Https").finish(),
                        Scheme::Other(e) => {
                            f.debug_tuple("Scheme::Other").field(e).finish()
                        }
                    }
                }
            }
            /// Defines the case payload type for `DNS-error` above:
            #[derive(Clone)]
            pub struct DnsErrorPayload {
                pub rcode: Option<_rt::String>,
                pub info_code: Option<u16>,
            }
            impl ::core::fmt::Debug for DnsErrorPayload {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("DnsErrorPayload")
                        .field("rcode", &self.rcode)
                        .field("info-code", &self.info_code)
                        .finish()
                }
            }
            /// Defines the case payload type for `TLS-alert-received` above:
            #[derive(Clone)]
            pub struct TlsAlertReceivedPayload {
                pub alert_id: Option<u8>,
                pub alert_message: Option<_rt::String>,
            }
            impl ::core::fmt::Debug for TlsAlertReceivedPayload {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("TlsAlertReceivedPayload")
                        .field("alert-id", &self.alert_id)
                        .field("alert-message", &self.alert_message)
                        .finish()
                }
            }
            /// Defines the case payload type for `HTTP-response-{header,trailer}-size` above:
            #[derive(Clone)]
            pub struct FieldSizePayload {
                pub field_name: Option<_rt::String>,
                pub field_size: Option<u32>,
            }
            impl ::core::fmt::Debug for FieldSizePayload {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("FieldSizePayload")
                        .field("field-name", &self.field_name)
                        .field("field-size", &self.field_size)
                        .finish()
                }
            }
            /// These cases are inspired by the IANA HTTP Proxy Error Types:
            ///   <https://www.iana.org/assignments/http-proxy-status/http-proxy-status.xhtml#table-http-proxy-error-types>
            #[derive(Clone)]
            pub enum ErrorCode {
                DnsTimeout,
                DnsError(DnsErrorPayload),
                DestinationNotFound,
                DestinationUnavailable,
                DestinationIpProhibited,
                DestinationIpUnroutable,
                ConnectionRefused,
                ConnectionTerminated,
                ConnectionTimeout,
                ConnectionReadTimeout,
                ConnectionWriteTimeout,
                ConnectionLimitReached,
                TlsProtocolError,
                TlsCertificateError,
                TlsAlertReceived(TlsAlertReceivedPayload),
                HttpRequestDenied,
                HttpRequestLengthRequired,
                HttpRequestBodySize(Option<u64>),
                HttpRequestMethodInvalid,
                HttpRequestUriInvalid,
                HttpRequestUriTooLong,
                HttpRequestHeaderSectionSize(Option<u32>),
                HttpRequestHeaderSize(Option<FieldSizePayload>),
                HttpRequestTrailerSectionSize(Option<u32>),
                HttpRequestTrailerSize(FieldSizePayload),
                HttpResponseIncomplete,
                HttpResponseHeaderSectionSize(Option<u32>),
                HttpResponseHeaderSize(FieldSizePayload),
                HttpResponseBodySize(Option<u64>),
                HttpResponseTrailerSectionSize(Option<u32>),
                HttpResponseTrailerSize(FieldSizePayload),
                HttpResponseTransferCoding(Option<_rt::String>),
                HttpResponseContentCoding(Option<_rt::String>),
                HttpResponseTimeout,
                HttpUpgradeFailed,
                HttpProtocolError,
                LoopDetected,
                ConfigurationError,
                /// This is a catch-all error for anything that doesn't fit cleanly into a
                /// more specific case. It also includes an optional string for an
                /// unstructured description of the error. Users should not depend on the
                /// string for diagnosing errors, as it's not required to be consistent
                /// between implementations.
                InternalError(Option<_rt::String>),
            }
            impl ::core::fmt::Debug for ErrorCode {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        ErrorCode::DnsTimeout => {
                            f.debug_tuple("ErrorCode::DnsTimeout").finish()
                        }
                        ErrorCode::DnsError(e) => {
                            f.debug_tuple("ErrorCode::DnsError").field(e).finish()
                        }
                        ErrorCode::DestinationNotFound => {
                            f.debug_tuple("ErrorCode::DestinationNotFound").finish()
                        }
                        ErrorCode::DestinationUnavailable => {
                            f.debug_tuple("ErrorCode::DestinationUnavailable").finish()
                        }
                        ErrorCode::DestinationIpProhibited => {
                            f.debug_tuple("ErrorCode::DestinationIpProhibited").finish()
                        }
                        ErrorCode::DestinationIpUnroutable => {
                            f.debug_tuple("ErrorCode::DestinationIpUnroutable").finish()
                        }
                        ErrorCode::ConnectionRefused => {
                            f.debug_tuple("ErrorCode::ConnectionRefused").finish()
                        }
                        ErrorCode::ConnectionTerminated => {
                            f.debug_tuple("ErrorCode::ConnectionTerminated").finish()
                        }
                        ErrorCode::ConnectionTimeout => {
                            f.debug_tuple("ErrorCode::ConnectionTimeout").finish()
                        }
                        ErrorCode::ConnectionReadTimeout => {
                            f.debug_tuple("ErrorCode::ConnectionReadTimeout").finish()
                        }
                        ErrorCode::ConnectionWriteTimeout => {
                            f.debug_tuple("ErrorCode::ConnectionWriteTimeout").finish()
                        }
                        ErrorCode::ConnectionLimitReached => {
                            f.debug_tuple("ErrorCode::ConnectionLimitReached").finish()
                        }
                        ErrorCode::TlsProtocolError => {
                            f.debug_tuple("ErrorCode::TlsProtocolError").finish()
                        }
                        ErrorCode::TlsCertificateError => {
                            f.debug_tuple("ErrorCode::TlsCertificateError").finish()
                        }
                        ErrorCode::TlsAlertReceived(e) => {
                            f.debug_tuple("ErrorCode::TlsAlertReceived")
                                .field(e)
                                .finish()
                        }
                        ErrorCode::HttpRequestDenied => {
                            f.debug_tuple("ErrorCode::HttpRequestDenied").finish()
                        }
                        ErrorCode::HttpRequestLengthRequired => {
                            f.debug_tuple("ErrorCode::HttpRequestLengthRequired")
                                .finish()
                        }
                        ErrorCode::HttpRequestBodySize(e) => {
                            f.debug_tuple("ErrorCode::HttpRequestBodySize")
                                .field(e)
                                .finish()
                        }
                        ErrorCode::HttpRequestMethodInvalid => {
                            f.debug_tuple("ErrorCode::HttpRequestMethodInvalid").finish()
                        }
                        ErrorCode::HttpRequestUriInvalid => {
                            f.debug_tuple("ErrorCode::HttpRequestUriInvalid").finish()
                        }
                        ErrorCode::HttpRequestUriTooLong => {
                            f.debug_tuple("ErrorCode::HttpRequestUriTooLong").finish()
                        }
                        ErrorCode::HttpRequestHeaderSectionSize(e) => {
                            f.debug_tuple("ErrorCode::HttpRequestHeaderSectionSize")
                                .field(e)
                                .finish()
                        }
                        ErrorCode::HttpRequestHeaderSize(e) => {
                            f.debug_tuple("ErrorCode::HttpRequestHeaderSize")
                                .field(e)
                                .finish()
                        }
                        ErrorCode::HttpRequestTrailerSectionSize(e) => {
                            f.debug_tuple("ErrorCode::HttpRequestTrailerSectionSize")
                                .field(e)
                                .finish()
                        }
                        ErrorCode::HttpRequestTrailerSize(e) => {
                            f.debug_tuple("ErrorCode::HttpRequestTrailerSize")
                                .field(e)
                                .finish()
                        }
                        ErrorCode::HttpResponseIncomplete => {
                            f.debug_tuple("ErrorCode::HttpResponseIncomplete").finish()
                        }
                        ErrorCode::HttpResponseHeaderSectionSize(e) => {
                            f.debug_tuple("ErrorCode::HttpResponseHeaderSectionSize")
                                .field(e)
                                .finish()
                        }
                        ErrorCode::HttpResponseHeaderSize(e) => {
                            f.debug_tuple("ErrorCode::HttpResponseHeaderSize")
                                .field(e)
                                .finish()
                        }
                        ErrorCode::HttpResponseBodySize(e) => {
                            f.debug_tuple("ErrorCode::HttpResponseBodySize")
                                .field(e)
                                .finish()
                        }
                        ErrorCode::HttpResponseTrailerSectionSize(e) => {
                            f.debug_tuple("ErrorCode::HttpResponseTrailerSectionSize")
                                .field(e)
                                .finish()
                        }
                        ErrorCode::HttpResponseTrailerSize(e) => {
                            f.debug_tuple("ErrorCode::HttpResponseTrailerSize")
                                .field(e)
                                .finish()
                        }
                        ErrorCode::HttpResponseTransferCoding(e) => {
                            f.debug_tuple("ErrorCode::HttpResponseTransferCoding")
                                .field(e)
                                .finish()
                        }
                        ErrorCode::HttpResponseContentCoding(e) => {
                            f.debug_tuple("ErrorCode::HttpResponseContentCoding")
                                .field(e)
                                .finish()
                        }
                        ErrorCode::HttpResponseTimeout => {
                            f.debug_tuple("ErrorCode::HttpResponseTimeout").finish()
                        }
                        ErrorCode::HttpUpgradeFailed => {
                            f.debug_tuple("ErrorCode::HttpUpgradeFailed").finish()
                        }
                        ErrorCode::HttpProtocolError => {
                            f.debug_tuple("ErrorCode::HttpProtocolError").finish()
                        }
                        ErrorCode::LoopDetected => {
                            f.debug_tuple("ErrorCode::LoopDetected").finish()
                        }
                        ErrorCode::ConfigurationError => {
                            f.debug_tuple("ErrorCode::ConfigurationError").finish()
                        }
                        ErrorCode::InternalError(e) => {
                            f.debug_tuple("ErrorCode::InternalError").field(e).finish()
                        }
                    }
                }
            }
            impl ::core::fmt::Display for ErrorCode {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    write!(f, "{:?}", self)
                }
            }
            impl ::core::error::Error for ErrorCode {}
            /// This type enumerates the different kinds of errors that may occur when
            /// setting or appending to a `fields` resource.
            #[derive(Clone, Copy)]
            pub enum HeaderError {
                /// This error indicates that a `field-name` or `field-value` was
                /// syntactically invalid when used with an operation that sets headers in a
                /// `fields`.
                InvalidSyntax,
                /// This error indicates that a forbidden `field-name` was used when trying
                /// to set a header in a `fields`.
                Forbidden,
                /// This error indicates that the operation on the `fields` was not
                /// permitted because the fields are immutable.
                Immutable,
            }
            impl ::core::fmt::Debug for HeaderError {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        HeaderError::InvalidSyntax => {
                            f.debug_tuple("HeaderError::InvalidSyntax").finish()
                        }
                        HeaderError::Forbidden => {
                            f.debug_tuple("HeaderError::Forbidden").finish()
                        }
                        HeaderError::Immutable => {
                            f.debug_tuple("HeaderError::Immutable").finish()
                        }
                    }
                }
            }
            impl ::core::fmt::Display for HeaderError {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    write!(f, "{:?}", self)
                }
            }
            impl ::core::error::Error for HeaderError {}
            /// This type enumerates the different kinds of errors that may occur when
            /// setting fields of a `request-options` resource.
            #[derive(Clone, Copy)]
            pub enum RequestOptionsError {
                /// Indicates the specified field is not supported by this implementation.
                NotSupported,
                /// Indicates that the operation on the `request-options` was not permitted
                /// because it is immutable.
                Immutable,
            }
            impl ::core::fmt::Debug for RequestOptionsError {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        RequestOptionsError::NotSupported => {
                            f.debug_tuple("RequestOptionsError::NotSupported").finish()
                        }
                        RequestOptionsError::Immutable => {
                            f.debug_tuple("RequestOptionsError::Immutable").finish()
                        }
                    }
                }
            }
            impl ::core::fmt::Display for RequestOptionsError {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    write!(f, "{:?}", self)
                }
            }
            impl ::core::error::Error for RequestOptionsError {}
            /// Field names are always strings.
            ///
            /// Field names should always be treated as case insensitive by the `fields`
            /// resource for the purposes of equality checking.
            pub type FieldName = _rt::String;
            /// Field values should always be ASCII strings. However, in
            /// reality, HTTP implementations often have to interpret malformed values,
            /// so they are provided as a list of bytes.
            pub type FieldValue = _rt::Vec<u8>;
            /// This following block defines the `fields` resource which corresponds to
            /// HTTP standard Fields. Fields are a common representation used for both
            /// Headers and Trailers.
            ///
            /// A `fields` may be mutable or immutable. A `fields` created using the
            /// constructor, `from-list`, or `clone` will be mutable, but a `fields`
            /// resource given by other means (including, but not limited to,
            /// `request.headers`) might be be immutable. In an immutable fields, the
            /// `set`, `append`, and `delete` operations will fail with
            /// `header-error.immutable`.
            ///
            /// A `fields` resource should store `field-name`s and `field-value`s in their
            /// original casing used to construct or mutate the `fields` resource. The `fields`
            /// resource should use that original casing when serializing the fields for
            /// transport or when returning them from a method.
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct Fields {
                handle: _rt::Resource<Fields>,
            }
            impl Fields {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: unsafe { _rt::Resource::from_handle(handle) },
                    }
                }
                #[doc(hidden)]
                pub fn take_handle(&self) -> u32 {
                    _rt::Resource::take_handle(&self.handle)
                }
                #[doc(hidden)]
                pub fn handle(&self) -> u32 {
                    _rt::Resource::handle(&self.handle)
                }
            }
            unsafe impl _rt::WasmResource for Fields {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06")]
                    unsafe extern "C" {
                        #[link_name = "[resource-drop]fields"]
                        fn drop(_: i32);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    unsafe extern "C" fn drop(_: i32) {
                        unreachable!()
                    }
                    unsafe {
                        drop(_handle as i32);
                    }
                }
            }
            /// Headers is an alias for Fields.
            pub type Headers = Fields;
            /// Trailers is an alias for Fields.
            pub type Trailers = Fields;
            /// Represents an HTTP Request.
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct Request {
                handle: _rt::Resource<Request>,
            }
            impl Request {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: unsafe { _rt::Resource::from_handle(handle) },
                    }
                }
                #[doc(hidden)]
                pub fn take_handle(&self) -> u32 {
                    _rt::Resource::take_handle(&self.handle)
                }
                #[doc(hidden)]
                pub fn handle(&self) -> u32 {
                    _rt::Resource::handle(&self.handle)
                }
            }
            unsafe impl _rt::WasmResource for Request {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06")]
                    unsafe extern "C" {
                        #[link_name = "[resource-drop]request"]
                        fn drop(_: i32);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    unsafe extern "C" fn drop(_: i32) {
                        unreachable!()
                    }
                    unsafe {
                        drop(_handle as i32);
                    }
                }
            }
            /// Parameters for making an HTTP Request. Each of these parameters is
            /// currently an optional timeout applicable to the transport layer of the
            /// HTTP protocol.
            ///
            /// These timeouts are separate from any the user may use to bound an
            /// asynchronous call.
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct RequestOptions {
                handle: _rt::Resource<RequestOptions>,
            }
            impl RequestOptions {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: unsafe { _rt::Resource::from_handle(handle) },
                    }
                }
                #[doc(hidden)]
                pub fn take_handle(&self) -> u32 {
                    _rt::Resource::take_handle(&self.handle)
                }
                #[doc(hidden)]
                pub fn handle(&self) -> u32 {
                    _rt::Resource::handle(&self.handle)
                }
            }
            unsafe impl _rt::WasmResource for RequestOptions {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06")]
                    unsafe extern "C" {
                        #[link_name = "[resource-drop]request-options"]
                        fn drop(_: i32);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    unsafe extern "C" fn drop(_: i32) {
                        unreachable!()
                    }
                    unsafe {
                        drop(_handle as i32);
                    }
                }
            }
            /// This type corresponds to the HTTP standard Status Code.
            pub type StatusCode = u16;
            /// Represents an HTTP Response.
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct Response {
                handle: _rt::Resource<Response>,
            }
            impl Response {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: unsafe { _rt::Resource::from_handle(handle) },
                    }
                }
                #[doc(hidden)]
                pub fn take_handle(&self) -> u32 {
                    _rt::Resource::take_handle(&self.handle)
                }
                #[doc(hidden)]
                pub fn handle(&self) -> u32 {
                    _rt::Resource::handle(&self.handle)
                }
            }
            unsafe impl _rt::WasmResource for Response {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06")]
                    unsafe extern "C" {
                        #[link_name = "[resource-drop]response"]
                        fn drop(_: i32);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    unsafe extern "C" fn drop(_: i32) {
                        unreachable!()
                    }
                    unsafe {
                        drop(_handle as i32);
                    }
                }
            }
            impl Fields {
                #[allow(unused_unsafe, clippy::all)]
                /// Construct an empty HTTP Fields.
                ///
                /// The resulting `fields` is mutable.
                #[allow(async_fn_in_trait)]
                pub fn new() -> Self {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[constructor]fields"]
                            fn wit_import0() -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import0() -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import0();
                        Fields::from_handle(ret as u32)
                    }
                }
            }
            impl Fields {
                #[allow(unused_unsafe, clippy::all)]
                /// Construct an HTTP Fields.
                ///
                /// The resulting `fields` is mutable.
                ///
                /// The list represents each name-value pair in the Fields. Names
                /// which have multiple values are represented by multiple entries in this
                /// list with the same name.
                ///
                /// The tuple is a pair of the field name, represented as a string, and
                /// Value, represented as a list of bytes. In a valid Fields, all names
                /// and values are valid UTF-8 strings. However, values are not always
                /// well-formed, so they are represented as a raw list of bytes.
                ///
                /// An error result will be returned if any header or value was
                /// syntactically invalid, or if a header was forbidden.
                #[allow(async_fn_in_trait)]
                pub fn from_list(
                    entries: &[(FieldName, FieldValue)],
                ) -> Result<Fields, HeaderError> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 8],
                        );
                        let vec3 = entries;
                        let len3 = vec3.len();
                        let layout3 = _rt::alloc::Layout::from_size_align(
                                vec3.len() * (4 * ::core::mem::size_of::<*const u8>()),
                                ::core::mem::size_of::<*const u8>(),
                            )
                            .unwrap();
                        let (result3, _cleanup3) = wit_bindgen::rt::Cleanup::new(
                            layout3,
                        );
                        for (i, e) in vec3.into_iter().enumerate() {
                            let base = result3
                                .add(i * (4 * ::core::mem::size_of::<*const u8>()));
                            {
                                let (t0_0, t0_1) = e;
                                let vec1 = t0_0;
                                let ptr1 = vec1.as_ptr().cast::<u8>();
                                let len1 = vec1.len();
                                *base
                                    .add(::core::mem::size_of::<*const u8>())
                                    .cast::<usize>() = len1;
                                *base.add(0).cast::<*mut u8>() = ptr1.cast_mut();
                                let vec2 = t0_1;
                                let ptr2 = vec2.as_ptr().cast::<u8>();
                                let len2 = vec2.len();
                                *base
                                    .add(3 * ::core::mem::size_of::<*const u8>())
                                    .cast::<usize>() = len2;
                                *base
                                    .add(2 * ::core::mem::size_of::<*const u8>())
                                    .cast::<*mut u8>() = ptr2.cast_mut();
                            }
                        }
                        let ptr4 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[static]fields.from-list"]
                            fn wit_import5(_: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import5(
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import5(result3, len3, ptr4);
                        let l6 = i32::from(*ptr4.add(0).cast::<u8>());
                        let result10 = match l6 {
                            0 => {
                                let e = {
                                    let l7 = *ptr4.add(4).cast::<i32>();
                                    Fields::from_handle(l7 as u32)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l8 = i32::from(*ptr4.add(4).cast::<u8>());
                                    let v9 = match l8 {
                                        0 => HeaderError::InvalidSyntax,
                                        1 => HeaderError::Forbidden,
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            HeaderError::Immutable
                                        }
                                    };
                                    v9
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        };
                        result10
                    }
                }
            }
            impl Fields {
                #[allow(unused_unsafe, clippy::all)]
                /// Get all of the values corresponding to a name. If the name is not present
                /// in this `fields`, an empty list is returned. However, if the name is
                /// present but empty, this is represented by a list with one or more
                /// empty field-values present.
                #[allow(async_fn_in_trait)]
                pub fn get(&self, name: &str) -> _rt::Vec<FieldValue> {
                    unsafe {
                        #[cfg_attr(target_pointer_width = "64", repr(align(8)))]
                        #[cfg_attr(target_pointer_width = "32", repr(align(4)))]
                        struct RetArea(
                            [::core::mem::MaybeUninit<
                                u8,
                            >; 2 * ::core::mem::size_of::<*const u8>()],
                        );
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2
                                * ::core::mem::size_of::<*const u8>()],
                        );
                        let vec0 = name;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let ptr1 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]fields.get"]
                            fn wit_import2(_: i32, _: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import2(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import2((self).handle() as i32, ptr0.cast_mut(), len0, ptr1);
                        let l3 = *ptr1.add(0).cast::<*mut u8>();
                        let l4 = *ptr1
                            .add(::core::mem::size_of::<*const u8>())
                            .cast::<usize>();
                        let base8 = l3;
                        let len8 = l4;
                        let mut result8 = _rt::Vec::with_capacity(len8);
                        for i in 0..len8 {
                            let base = base8
                                .add(i * (2 * ::core::mem::size_of::<*const u8>()));
                            let e8 = {
                                let l5 = *base.add(0).cast::<*mut u8>();
                                let l6 = *base
                                    .add(::core::mem::size_of::<*const u8>())
                                    .cast::<usize>();
                                let len7 = l6;
                                <_ as From<
                                    _rt::Vec<_>,
                                >>::from(_rt::Vec::from_raw_parts(l5.cast(), len7, len7))
                            };
                            result8.push(e8);
                        }
                        _rt::cabi_dealloc(
                            base8,
                            len8 * (2 * ::core::mem::size_of::<*const u8>()),
                            ::core::mem::size_of::<*const u8>(),
                        );
                        let result9 = result8;
                        result9
                    }
                }
            }
            impl Fields {
                #[allow(unused_unsafe, clippy::all)]
                /// Returns `true` when the name is present in this `fields`. If the name is
                /// syntactically invalid, `false` is returned.
                #[allow(async_fn_in_trait)]
                pub fn has(&self, name: &str) -> bool {
                    unsafe {
                        let vec0 = name;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]fields.has"]
                            fn wit_import1(_: i32, _: *mut u8, _: usize) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import1(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                        ) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import1(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                        );
                        _rt::bool_lift(ret as u8)
                    }
                }
            }
            impl Fields {
                #[allow(unused_unsafe, clippy::all)]
                /// Set all of the values for a name. Clears any existing values for that
                /// name, if they have been set.
                ///
                /// Fails with `header-error.immutable` if the `fields` are immutable.
                #[allow(async_fn_in_trait)]
                pub fn set(
                    &self,
                    name: &str,
                    value: &[FieldValue],
                ) -> Result<(), HeaderError> {
                    unsafe {
                        #[repr(align(1))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2],
                        );
                        let vec0 = name;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let vec2 = value;
                        let len2 = vec2.len();
                        let layout2 = _rt::alloc::Layout::from_size_align(
                                vec2.len() * (2 * ::core::mem::size_of::<*const u8>()),
                                ::core::mem::size_of::<*const u8>(),
                            )
                            .unwrap();
                        let (result2, _cleanup2) = wit_bindgen::rt::Cleanup::new(
                            layout2,
                        );
                        for (i, e) in vec2.into_iter().enumerate() {
                            let base = result2
                                .add(i * (2 * ::core::mem::size_of::<*const u8>()));
                            {
                                let vec1 = e;
                                let ptr1 = vec1.as_ptr().cast::<u8>();
                                let len1 = vec1.len();
                                *base
                                    .add(::core::mem::size_of::<*const u8>())
                                    .cast::<usize>() = len1;
                                *base.add(0).cast::<*mut u8>() = ptr1.cast_mut();
                            }
                        }
                        let ptr3 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]fields.set"]
                            fn wit_import4(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import4(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import4(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            result2,
                            len2,
                            ptr3,
                        );
                        let l5 = i32::from(*ptr3.add(0).cast::<u8>());
                        let result8 = match l5 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l6 = i32::from(*ptr3.add(1).cast::<u8>());
                                    let v7 = match l6 {
                                        0 => HeaderError::InvalidSyntax,
                                        1 => HeaderError::Forbidden,
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            HeaderError::Immutable
                                        }
                                    };
                                    v7
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        };
                        result8
                    }
                }
            }
            impl Fields {
                #[allow(unused_unsafe, clippy::all)]
                /// Delete all values for a name. Does nothing if no values for the name
                /// exist.
                ///
                /// Fails with `header-error.immutable` if the `fields` are immutable.
                #[allow(async_fn_in_trait)]
                pub fn delete(&self, name: &str) -> Result<(), HeaderError> {
                    unsafe {
                        #[repr(align(1))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2],
                        );
                        let vec0 = name;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let ptr1 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]fields.delete"]
                            fn wit_import2(_: i32, _: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import2(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import2((self).handle() as i32, ptr0.cast_mut(), len0, ptr1);
                        let l3 = i32::from(*ptr1.add(0).cast::<u8>());
                        let result6 = match l3 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l4 = i32::from(*ptr1.add(1).cast::<u8>());
                                    let v5 = match l4 {
                                        0 => HeaderError::InvalidSyntax,
                                        1 => HeaderError::Forbidden,
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            HeaderError::Immutable
                                        }
                                    };
                                    v5
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        };
                        result6
                    }
                }
            }
            impl Fields {
                #[allow(unused_unsafe, clippy::all)]
                /// Delete all values for a name. Does nothing if no values for the name
                /// exist.
                ///
                /// Returns all values previously corresponding to the name, if any.
                ///
                /// Fails with `header-error.immutable` if the `fields` are immutable.
                #[allow(async_fn_in_trait)]
                pub fn get_and_delete(
                    &self,
                    name: &str,
                ) -> Result<_rt::Vec<FieldValue>, HeaderError> {
                    unsafe {
                        #[cfg_attr(target_pointer_width = "64", repr(align(8)))]
                        #[cfg_attr(target_pointer_width = "32", repr(align(4)))]
                        struct RetArea(
                            [::core::mem::MaybeUninit<
                                u8,
                            >; 3 * ::core::mem::size_of::<*const u8>()],
                        );
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 3
                                * ::core::mem::size_of::<*const u8>()],
                        );
                        let vec0 = name;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let ptr1 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]fields.get-and-delete"]
                            fn wit_import2(_: i32, _: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import2(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import2((self).handle() as i32, ptr0.cast_mut(), len0, ptr1);
                        let l3 = i32::from(*ptr1.add(0).cast::<u8>());
                        let result12 = match l3 {
                            0 => {
                                let e = {
                                    let l4 = *ptr1
                                        .add(::core::mem::size_of::<*const u8>())
                                        .cast::<*mut u8>();
                                    let l5 = *ptr1
                                        .add(2 * ::core::mem::size_of::<*const u8>())
                                        .cast::<usize>();
                                    let base9 = l4;
                                    let len9 = l5;
                                    let mut result9 = _rt::Vec::with_capacity(len9);
                                    for i in 0..len9 {
                                        let base = base9
                                            .add(i * (2 * ::core::mem::size_of::<*const u8>()));
                                        let e9 = {
                                            let l6 = *base.add(0).cast::<*mut u8>();
                                            let l7 = *base
                                                .add(::core::mem::size_of::<*const u8>())
                                                .cast::<usize>();
                                            let len8 = l7;
                                            <_ as From<
                                                _rt::Vec<_>,
                                            >>::from(_rt::Vec::from_raw_parts(l6.cast(), len8, len8))
                                        };
                                        result9.push(e9);
                                    }
                                    _rt::cabi_dealloc(
                                        base9,
                                        len9 * (2 * ::core::mem::size_of::<*const u8>()),
                                        ::core::mem::size_of::<*const u8>(),
                                    );
                                    result9
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l10 = i32::from(
                                        *ptr1.add(::core::mem::size_of::<*const u8>()).cast::<u8>(),
                                    );
                                    let v11 = match l10 {
                                        0 => HeaderError::InvalidSyntax,
                                        1 => HeaderError::Forbidden,
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            HeaderError::Immutable
                                        }
                                    };
                                    v11
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        };
                        result12
                    }
                }
            }
            impl Fields {
                #[allow(unused_unsafe, clippy::all)]
                /// Append a value for a name. Does not change or delete any existing
                /// values for that name.
                ///
                /// Fails with `header-error.immutable` if the `fields` are immutable.
                #[allow(async_fn_in_trait)]
                pub fn append(
                    &self,
                    name: &str,
                    value: &[u8],
                ) -> Result<(), HeaderError> {
                    unsafe {
                        #[repr(align(1))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2],
                        );
                        let vec0 = name;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let vec1 = value;
                        let ptr1 = vec1.as_ptr().cast::<u8>();
                        let len1 = vec1.len();
                        let ptr2 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]fields.append"]
                            fn wit_import3(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import3(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import3(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            ptr1.cast_mut(),
                            len1,
                            ptr2,
                        );
                        let l4 = i32::from(*ptr2.add(0).cast::<u8>());
                        let result7 = match l4 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l5 = i32::from(*ptr2.add(1).cast::<u8>());
                                    let v6 = match l5 {
                                        0 => HeaderError::InvalidSyntax,
                                        1 => HeaderError::Forbidden,
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            HeaderError::Immutable
                                        }
                                    };
                                    v6
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        };
                        result7
                    }
                }
            }
            impl Fields {
                #[allow(unused_unsafe, clippy::all)]
                /// Retrieve the full set of names and values in the Fields. Like the
                /// constructor, the list represents each name-value pair.
                ///
                /// The outer list represents each name-value pair in the Fields. Names
                /// which have multiple values are represented by multiple entries in this
                /// list with the same name.
                ///
                /// The names and values are always returned in the original casing and in
                /// the order in which they will be serialized for transport.
                #[allow(async_fn_in_trait)]
                pub fn copy_all(&self) -> _rt::Vec<(FieldName, FieldValue)> {
                    unsafe {
                        #[cfg_attr(target_pointer_width = "64", repr(align(8)))]
                        #[cfg_attr(target_pointer_width = "32", repr(align(4)))]
                        struct RetArea(
                            [::core::mem::MaybeUninit<
                                u8,
                            >; 2 * ::core::mem::size_of::<*const u8>()],
                        );
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2
                                * ::core::mem::size_of::<*const u8>()],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]fields.copy-all"]
                            fn wit_import1(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import1(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import1((self).handle() as i32, ptr0);
                        let l2 = *ptr0.add(0).cast::<*mut u8>();
                        let l3 = *ptr0
                            .add(::core::mem::size_of::<*const u8>())
                            .cast::<usize>();
                        let base10 = l2;
                        let len10 = l3;
                        let mut result10 = _rt::Vec::with_capacity(len10);
                        for i in 0..len10 {
                            let base = base10
                                .add(i * (4 * ::core::mem::size_of::<*const u8>()));
                            let e10 = {
                                let l4 = *base.add(0).cast::<*mut u8>();
                                let l5 = *base
                                    .add(::core::mem::size_of::<*const u8>())
                                    .cast::<usize>();
                                let len6 = l5;
                                let bytes6 = _rt::Vec::from_raw_parts(
                                    l4.cast(),
                                    len6,
                                    len6,
                                );
                                let l7 = *base
                                    .add(2 * ::core::mem::size_of::<*const u8>())
                                    .cast::<*mut u8>();
                                let l8 = *base
                                    .add(3 * ::core::mem::size_of::<*const u8>())
                                    .cast::<usize>();
                                let len9 = l8;
                                (
                                    _rt::string_lift(bytes6),
                                    <_ as From<
                                        _rt::Vec<_>,
                                    >>::from(_rt::Vec::from_raw_parts(l7.cast(), len9, len9)),
                                )
                            };
                            result10.push(e10);
                        }
                        _rt::cabi_dealloc(
                            base10,
                            len10 * (4 * ::core::mem::size_of::<*const u8>()),
                            ::core::mem::size_of::<*const u8>(),
                        );
                        let result11 = result10;
                        result11
                    }
                }
            }
            impl Fields {
                #[allow(unused_unsafe, clippy::all)]
                /// Make a deep copy of the Fields. Equivalent in behavior to calling the
                /// `fields` constructor on the return value of `copy-all`. The resulting
                /// `fields` is mutable.
                #[allow(async_fn_in_trait)]
                pub fn clone(&self) -> Fields {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]fields.clone"]
                            fn wit_import0(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import0(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import0((self).handle() as i32);
                        Fields::from_handle(ret as u32)
                    }
                }
            }
            impl Request {
                #[allow(unused_unsafe, clippy::all)]
                /// Construct a new `request` with a default `method` of `GET`, and
                /// `none` values for `path-with-query`, `scheme`, and `authority`.
                ///
                /// `headers` is the HTTP Headers for the Request.
                ///
                /// `contents` is the optional body content stream with `none`
                /// representing a zero-length content stream.
                /// Once it is closed, `trailers` future must resolve to a result.
                /// If `trailers` resolves to an error, underlying connection
                /// will be closed immediately.
                ///
                /// `options` is optional `request-options` resource to be used
                /// if the request is sent over a network connection.
                ///
                /// It is possible to construct, or manipulate with the accessor functions
                /// below, a `request` with an invalid combination of `scheme`
                /// and `authority`, or `headers` which are not permitted to be sent.
                /// It is the obligation of the `handler.handle` implementation
                /// to reject invalid constructions of `request`.
                ///
                /// The returned future resolves to result of transmission of this request.
                #[allow(async_fn_in_trait)]
                pub fn new(
                    headers: Headers,
                    contents: Option<wit_bindgen::rt::async_support::StreamReader<u8>>,
                    trailers: wit_bindgen::rt::async_support::FutureReader<
                        Result<Option<Trailers>, ErrorCode>,
                    >,
                    options: Option<RequestOptions>,
                ) -> (
                    Request,
                    wit_bindgen::rt::async_support::FutureReader<Result<(), ErrorCode>>,
                ) {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 8],
                        );
                        let (result0_0, result0_1) = match &contents {
                            Some(e) => (1i32, (e).take_handle() as i32),
                            None => (0i32, 0i32),
                        };
                        let (result1_0, result1_1) = match &options {
                            Some(e) => (1i32, (e).take_handle() as i32),
                            None => (0i32, 0i32),
                        };
                        let ptr2 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[static]request.new"]
                            fn wit_import3(
                                _: i32,
                                _: i32,
                                _: i32,
                                _: i32,
                                _: i32,
                                _: i32,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import3(
                            _: i32,
                            _: i32,
                            _: i32,
                            _: i32,
                            _: i32,
                            _: i32,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import3(
                            (&headers).take_handle() as i32,
                            result0_0,
                            result0_1,
                            (&trailers).take_handle() as i32,
                            result1_0,
                            result1_1,
                            ptr2,
                        );
                        let l4 = *ptr2.add(0).cast::<i32>();
                        let l5 = *ptr2.add(4).cast::<i32>();
                        let result6 = (
                            Request::from_handle(l4 as u32),
                            wit_bindgen::rt::async_support::FutureReader::new(
                                l5 as u32,
                                &super::super::super::wit_future::vtable1::VTABLE,
                            ),
                        );
                        result6
                    }
                }
            }
            impl Request {
                #[allow(unused_unsafe, clippy::all)]
                /// Get the Method for the Request.
                #[allow(async_fn_in_trait)]
                pub fn get_method(&self) -> Method {
                    unsafe {
                        #[cfg_attr(target_pointer_width = "64", repr(align(8)))]
                        #[cfg_attr(target_pointer_width = "32", repr(align(4)))]
                        struct RetArea(
                            [::core::mem::MaybeUninit<
                                u8,
                            >; 3 * ::core::mem::size_of::<*const u8>()],
                        );
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 3
                                * ::core::mem::size_of::<*const u8>()],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]request.get-method"]
                            fn wit_import1(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import1(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import1((self).handle() as i32, ptr0);
                        let l2 = i32::from(*ptr0.add(0).cast::<u8>());
                        let v6 = match l2 {
                            0 => Method::Get,
                            1 => Method::Head,
                            2 => Method::Post,
                            3 => Method::Put,
                            4 => Method::Delete,
                            5 => Method::Connect,
                            6 => Method::Options,
                            7 => Method::Trace,
                            8 => Method::Patch,
                            n => {
                                debug_assert_eq!(n, 9, "invalid enum discriminant");
                                let e6 = {
                                    let l3 = *ptr0
                                        .add(::core::mem::size_of::<*const u8>())
                                        .cast::<*mut u8>();
                                    let l4 = *ptr0
                                        .add(2 * ::core::mem::size_of::<*const u8>())
                                        .cast::<usize>();
                                    let len5 = l4;
                                    let bytes5 = _rt::Vec::from_raw_parts(
                                        l3.cast(),
                                        len5,
                                        len5,
                                    );
                                    _rt::string_lift(bytes5)
                                };
                                Method::Other(e6)
                            }
                        };
                        let result7 = v6;
                        result7
                    }
                }
            }
            impl Request {
                #[allow(unused_unsafe, clippy::all)]
                /// Set the Method for the Request. Fails if the string present in a
                /// `method.other` argument is not a syntactically valid method.
                #[allow(async_fn_in_trait)]
                pub fn set_method(&self, method: &Method) -> Result<(), ()> {
                    unsafe {
                        let (result1_0, result1_1, result1_2) = match method {
                            Method::Get => (0i32, ::core::ptr::null_mut(), 0usize),
                            Method::Head => (1i32, ::core::ptr::null_mut(), 0usize),
                            Method::Post => (2i32, ::core::ptr::null_mut(), 0usize),
                            Method::Put => (3i32, ::core::ptr::null_mut(), 0usize),
                            Method::Delete => (4i32, ::core::ptr::null_mut(), 0usize),
                            Method::Connect => (5i32, ::core::ptr::null_mut(), 0usize),
                            Method::Options => (6i32, ::core::ptr::null_mut(), 0usize),
                            Method::Trace => (7i32, ::core::ptr::null_mut(), 0usize),
                            Method::Patch => (8i32, ::core::ptr::null_mut(), 0usize),
                            Method::Other(e) => {
                                let vec0 = e;
                                let ptr0 = vec0.as_ptr().cast::<u8>();
                                let len0 = vec0.len();
                                (9i32, ptr0.cast_mut(), len0)
                            }
                        };
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]request.set-method"]
                            fn wit_import2(_: i32, _: i32, _: *mut u8, _: usize) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import2(
                            _: i32,
                            _: i32,
                            _: *mut u8,
                            _: usize,
                        ) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import2(
                            (self).handle() as i32,
                            result1_0,
                            result1_1,
                            result1_2,
                        );
                        match ret {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = ();
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Request {
                #[allow(unused_unsafe, clippy::all)]
                /// Get the combination of the HTTP Path and Query for the Request.  When
                /// `none`, this represents an empty Path and empty Query.
                #[allow(async_fn_in_trait)]
                pub fn get_path_with_query(&self) -> Option<_rt::String> {
                    unsafe {
                        #[cfg_attr(target_pointer_width = "64", repr(align(8)))]
                        #[cfg_attr(target_pointer_width = "32", repr(align(4)))]
                        struct RetArea(
                            [::core::mem::MaybeUninit<
                                u8,
                            >; 3 * ::core::mem::size_of::<*const u8>()],
                        );
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 3
                                * ::core::mem::size_of::<*const u8>()],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]request.get-path-with-query"]
                            fn wit_import1(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import1(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import1((self).handle() as i32, ptr0);
                        let l2 = i32::from(*ptr0.add(0).cast::<u8>());
                        let result6 = match l2 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l3 = *ptr0
                                        .add(::core::mem::size_of::<*const u8>())
                                        .cast::<*mut u8>();
                                    let l4 = *ptr0
                                        .add(2 * ::core::mem::size_of::<*const u8>())
                                        .cast::<usize>();
                                    let len5 = l4;
                                    let bytes5 = _rt::Vec::from_raw_parts(
                                        l3.cast(),
                                        len5,
                                        len5,
                                    );
                                    _rt::string_lift(bytes5)
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        };
                        result6
                    }
                }
            }
            impl Request {
                #[allow(unused_unsafe, clippy::all)]
                /// Set the combination of the HTTP Path and Query for the Request.  When
                /// `none`, this represents an empty Path and empty Query. Fails is the
                /// string given is not a syntactically valid path and query uri component.
                #[allow(async_fn_in_trait)]
                pub fn set_path_with_query(
                    &self,
                    path_with_query: Option<&str>,
                ) -> Result<(), ()> {
                    unsafe {
                        let (result1_0, result1_1, result1_2) = match path_with_query {
                            Some(e) => {
                                let vec0 = e;
                                let ptr0 = vec0.as_ptr().cast::<u8>();
                                let len0 = vec0.len();
                                (1i32, ptr0.cast_mut(), len0)
                            }
                            None => (0i32, ::core::ptr::null_mut(), 0usize),
                        };
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]request.set-path-with-query"]
                            fn wit_import2(_: i32, _: i32, _: *mut u8, _: usize) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import2(
                            _: i32,
                            _: i32,
                            _: *mut u8,
                            _: usize,
                        ) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import2(
                            (self).handle() as i32,
                            result1_0,
                            result1_1,
                            result1_2,
                        );
                        match ret {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = ();
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Request {
                #[allow(unused_unsafe, clippy::all)]
                /// Get the HTTP Related Scheme for the Request. When `none`, the
                /// implementation may choose an appropriate default scheme.
                #[allow(async_fn_in_trait)]
                pub fn get_scheme(&self) -> Option<Scheme> {
                    unsafe {
                        #[cfg_attr(target_pointer_width = "64", repr(align(8)))]
                        #[cfg_attr(target_pointer_width = "32", repr(align(4)))]
                        struct RetArea(
                            [::core::mem::MaybeUninit<
                                u8,
                            >; 4 * ::core::mem::size_of::<*const u8>()],
                        );
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 4
                                * ::core::mem::size_of::<*const u8>()],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]request.get-scheme"]
                            fn wit_import1(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import1(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import1((self).handle() as i32, ptr0);
                        let l2 = i32::from(*ptr0.add(0).cast::<u8>());
                        let result8 = match l2 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l3 = i32::from(
                                        *ptr0.add(::core::mem::size_of::<*const u8>()).cast::<u8>(),
                                    );
                                    let v7 = match l3 {
                                        0 => Scheme::Http,
                                        1 => Scheme::Https,
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            let e7 = {
                                                let l4 = *ptr0
                                                    .add(2 * ::core::mem::size_of::<*const u8>())
                                                    .cast::<*mut u8>();
                                                let l5 = *ptr0
                                                    .add(3 * ::core::mem::size_of::<*const u8>())
                                                    .cast::<usize>();
                                                let len6 = l5;
                                                let bytes6 = _rt::Vec::from_raw_parts(
                                                    l4.cast(),
                                                    len6,
                                                    len6,
                                                );
                                                _rt::string_lift(bytes6)
                                            };
                                            Scheme::Other(e7)
                                        }
                                    };
                                    v7
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        };
                        result8
                    }
                }
            }
            impl Request {
                #[allow(unused_unsafe, clippy::all)]
                /// Set the HTTP Related Scheme for the Request. When `none`, the
                /// implementation may choose an appropriate default scheme. Fails if the
                /// string given is not a syntactically valid uri scheme.
                #[allow(async_fn_in_trait)]
                pub fn set_scheme(&self, scheme: Option<&Scheme>) -> Result<(), ()> {
                    unsafe {
                        let (result2_0, result2_1, result2_2, result2_3) = match scheme {
                            Some(e) => {
                                let (result1_0, result1_1, result1_2) = match e {
                                    Scheme::Http => (0i32, ::core::ptr::null_mut(), 0usize),
                                    Scheme::Https => (1i32, ::core::ptr::null_mut(), 0usize),
                                    Scheme::Other(e) => {
                                        let vec0 = e;
                                        let ptr0 = vec0.as_ptr().cast::<u8>();
                                        let len0 = vec0.len();
                                        (2i32, ptr0.cast_mut(), len0)
                                    }
                                };
                                (1i32, result1_0, result1_1, result1_2)
                            }
                            None => (0i32, 0i32, ::core::ptr::null_mut(), 0usize),
                        };
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]request.set-scheme"]
                            fn wit_import3(
                                _: i32,
                                _: i32,
                                _: i32,
                                _: *mut u8,
                                _: usize,
                            ) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import3(
                            _: i32,
                            _: i32,
                            _: i32,
                            _: *mut u8,
                            _: usize,
                        ) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import3(
                            (self).handle() as i32,
                            result2_0,
                            result2_1,
                            result2_2,
                            result2_3,
                        );
                        match ret {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = ();
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Request {
                #[allow(unused_unsafe, clippy::all)]
                /// Get the authority of the Request's target URI. A value of `none` may be used
                /// with Related Schemes which do not require an authority. The HTTP and
                /// HTTPS schemes always require an authority.
                #[allow(async_fn_in_trait)]
                pub fn get_authority(&self) -> Option<_rt::String> {
                    unsafe {
                        #[cfg_attr(target_pointer_width = "64", repr(align(8)))]
                        #[cfg_attr(target_pointer_width = "32", repr(align(4)))]
                        struct RetArea(
                            [::core::mem::MaybeUninit<
                                u8,
                            >; 3 * ::core::mem::size_of::<*const u8>()],
                        );
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 3
                                * ::core::mem::size_of::<*const u8>()],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]request.get-authority"]
                            fn wit_import1(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import1(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import1((self).handle() as i32, ptr0);
                        let l2 = i32::from(*ptr0.add(0).cast::<u8>());
                        let result6 = match l2 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l3 = *ptr0
                                        .add(::core::mem::size_of::<*const u8>())
                                        .cast::<*mut u8>();
                                    let l4 = *ptr0
                                        .add(2 * ::core::mem::size_of::<*const u8>())
                                        .cast::<usize>();
                                    let len5 = l4;
                                    let bytes5 = _rt::Vec::from_raw_parts(
                                        l3.cast(),
                                        len5,
                                        len5,
                                    );
                                    _rt::string_lift(bytes5)
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        };
                        result6
                    }
                }
            }
            impl Request {
                #[allow(unused_unsafe, clippy::all)]
                /// Set the authority of the Request's target URI. A value of `none` may be used
                /// with Related Schemes which do not require an authority. The HTTP and
                /// HTTPS schemes always require an authority. Fails if the string given is
                /// not a syntactically valid URI authority.
                #[allow(async_fn_in_trait)]
                pub fn set_authority(&self, authority: Option<&str>) -> Result<(), ()> {
                    unsafe {
                        let (result1_0, result1_1, result1_2) = match authority {
                            Some(e) => {
                                let vec0 = e;
                                let ptr0 = vec0.as_ptr().cast::<u8>();
                                let len0 = vec0.len();
                                (1i32, ptr0.cast_mut(), len0)
                            }
                            None => (0i32, ::core::ptr::null_mut(), 0usize),
                        };
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]request.set-authority"]
                            fn wit_import2(_: i32, _: i32, _: *mut u8, _: usize) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import2(
                            _: i32,
                            _: i32,
                            _: *mut u8,
                            _: usize,
                        ) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import2(
                            (self).handle() as i32,
                            result1_0,
                            result1_1,
                            result1_2,
                        );
                        match ret {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = ();
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Request {
                #[allow(unused_unsafe, clippy::all)]
                /// Get the `request-options` to be associated with this request
                ///
                /// The returned `request-options` resource is immutable: `set-*` operations
                /// will fail if invoked.
                ///
                /// This `request-options` resource is a child: it must be dropped before
                /// the parent `request` is dropped, or its ownership is transferred to
                /// another component by e.g. `handler.handle`.
                #[allow(async_fn_in_trait)]
                pub fn get_options(&self) -> Option<RequestOptions> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 8],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]request.get-options"]
                            fn wit_import1(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import1(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import1((self).handle() as i32, ptr0);
                        let l2 = i32::from(*ptr0.add(0).cast::<u8>());
                        let result4 = match l2 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l3 = *ptr0.add(4).cast::<i32>();
                                    RequestOptions::from_handle(l3 as u32)
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        };
                        result4
                    }
                }
            }
            impl Request {
                #[allow(unused_unsafe, clippy::all)]
                /// Get the headers associated with the Request.
                ///
                /// The returned `headers` resource is immutable: `set`, `append`, and
                /// `delete` operations will fail with `header-error.immutable`.
                #[allow(async_fn_in_trait)]
                pub fn get_headers(&self) -> Headers {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]request.get-headers"]
                            fn wit_import0(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import0(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import0((self).handle() as i32);
                        Fields::from_handle(ret as u32)
                    }
                }
            }
            impl Request {
                #[allow(unused_unsafe, clippy::all)]
                /// Get body of the Request.
                ///
                /// Stream returned by this method represents the contents of the body.
                /// Once the stream is reported as closed, callers should await the returned
                /// future to determine whether the body was received successfully.
                /// The future will only resolve after the stream is reported as closed.
                ///
                /// This function takes a `res` future as a parameter, which can be used to
                /// communicate an error in handling of the request.
                ///
                /// Note that function will move the `request`, but references to headers or
                /// request options acquired from it previously will remain valid.
                #[allow(async_fn_in_trait)]
                pub fn consume_body(
                    this: Request,
                    res: wit_bindgen::rt::async_support::FutureReader<
                        Result<(), ErrorCode>,
                    >,
                ) -> (
                    wit_bindgen::rt::async_support::StreamReader<u8>,
                    wit_bindgen::rt::async_support::FutureReader<
                        Result<Option<Trailers>, ErrorCode>,
                    >,
                ) {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 8],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[static]request.consume-body"]
                            fn wit_import1(_: i32, _: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import1(_: i32, _: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import1(
                            (&this).take_handle() as i32,
                            (&res).take_handle() as i32,
                            ptr0,
                        );
                        let l2 = *ptr0.add(0).cast::<i32>();
                        let l3 = *ptr0.add(4).cast::<i32>();
                        let result4 = (
                            wit_bindgen::rt::async_support::StreamReader::new(
                                l2 as u32,
                                &super::super::super::wit_stream::vtable0::VTABLE,
                            ),
                            wit_bindgen::rt::async_support::FutureReader::new(
                                l3 as u32,
                                &super::super::super::wit_future::vtable0::VTABLE,
                            ),
                        );
                        result4
                    }
                }
            }
            impl RequestOptions {
                #[allow(unused_unsafe, clippy::all)]
                /// Construct a default `request-options` value.
                #[allow(async_fn_in_trait)]
                pub fn new() -> Self {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[constructor]request-options"]
                            fn wit_import0() -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import0() -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import0();
                        RequestOptions::from_handle(ret as u32)
                    }
                }
            }
            impl RequestOptions {
                #[allow(unused_unsafe, clippy::all)]
                /// The timeout for the initial connect to the HTTP Server.
                #[allow(async_fn_in_trait)]
                pub fn get_connect_timeout(&self) -> Option<Duration> {
                    unsafe {
                        #[repr(align(8))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 16]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 16],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]request-options.get-connect-timeout"]
                            fn wit_import1(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import1(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import1((self).handle() as i32, ptr0);
                        let l2 = i32::from(*ptr0.add(0).cast::<u8>());
                        let result4 = match l2 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l3 = *ptr0.add(8).cast::<i64>();
                                    l3 as u64
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        };
                        result4
                    }
                }
            }
            impl RequestOptions {
                #[allow(unused_unsafe, clippy::all)]
                /// Set the timeout for the initial connect to the HTTP Server. An error
                /// return value indicates that this timeout is not supported or that this
                /// handle is immutable.
                #[allow(async_fn_in_trait)]
                pub fn set_connect_timeout(
                    &self,
                    duration: Option<Duration>,
                ) -> Result<(), RequestOptionsError> {
                    unsafe {
                        #[repr(align(1))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2],
                        );
                        let (result0_0, result0_1) = match duration {
                            Some(e) => (1i32, _rt::as_i64(e)),
                            None => (0i32, 0i64),
                        };
                        let ptr1 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]request-options.set-connect-timeout"]
                            fn wit_import2(_: i32, _: i32, _: i64, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import2(
                            _: i32,
                            _: i32,
                            _: i64,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import2((self).handle() as i32, result0_0, result0_1, ptr1);
                        let l3 = i32::from(*ptr1.add(0).cast::<u8>());
                        let result6 = match l3 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l4 = i32::from(*ptr1.add(1).cast::<u8>());
                                    let v5 = match l4 {
                                        0 => RequestOptionsError::NotSupported,
                                        n => {
                                            debug_assert_eq!(n, 1, "invalid enum discriminant");
                                            RequestOptionsError::Immutable
                                        }
                                    };
                                    v5
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        };
                        result6
                    }
                }
            }
            impl RequestOptions {
                #[allow(unused_unsafe, clippy::all)]
                /// The timeout for receiving the first byte of the Response body.
                #[allow(async_fn_in_trait)]
                pub fn get_first_byte_timeout(&self) -> Option<Duration> {
                    unsafe {
                        #[repr(align(8))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 16]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 16],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]request-options.get-first-byte-timeout"]
                            fn wit_import1(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import1(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import1((self).handle() as i32, ptr0);
                        let l2 = i32::from(*ptr0.add(0).cast::<u8>());
                        let result4 = match l2 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l3 = *ptr0.add(8).cast::<i64>();
                                    l3 as u64
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        };
                        result4
                    }
                }
            }
            impl RequestOptions {
                #[allow(unused_unsafe, clippy::all)]
                /// Set the timeout for receiving the first byte of the Response body. An
                /// error return value indicates that this timeout is not supported or that
                /// this handle is immutable.
                #[allow(async_fn_in_trait)]
                pub fn set_first_byte_timeout(
                    &self,
                    duration: Option<Duration>,
                ) -> Result<(), RequestOptionsError> {
                    unsafe {
                        #[repr(align(1))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2],
                        );
                        let (result0_0, result0_1) = match duration {
                            Some(e) => (1i32, _rt::as_i64(e)),
                            None => (0i32, 0i64),
                        };
                        let ptr1 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]request-options.set-first-byte-timeout"]
                            fn wit_import2(_: i32, _: i32, _: i64, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import2(
                            _: i32,
                            _: i32,
                            _: i64,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import2((self).handle() as i32, result0_0, result0_1, ptr1);
                        let l3 = i32::from(*ptr1.add(0).cast::<u8>());
                        let result6 = match l3 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l4 = i32::from(*ptr1.add(1).cast::<u8>());
                                    let v5 = match l4 {
                                        0 => RequestOptionsError::NotSupported,
                                        n => {
                                            debug_assert_eq!(n, 1, "invalid enum discriminant");
                                            RequestOptionsError::Immutable
                                        }
                                    };
                                    v5
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        };
                        result6
                    }
                }
            }
            impl RequestOptions {
                #[allow(unused_unsafe, clippy::all)]
                /// The timeout for receiving subsequent chunks of bytes in the Response
                /// body stream.
                #[allow(async_fn_in_trait)]
                pub fn get_between_bytes_timeout(&self) -> Option<Duration> {
                    unsafe {
                        #[repr(align(8))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 16]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 16],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]request-options.get-between-bytes-timeout"]
                            fn wit_import1(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import1(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import1((self).handle() as i32, ptr0);
                        let l2 = i32::from(*ptr0.add(0).cast::<u8>());
                        let result4 = match l2 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l3 = *ptr0.add(8).cast::<i64>();
                                    l3 as u64
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        };
                        result4
                    }
                }
            }
            impl RequestOptions {
                #[allow(unused_unsafe, clippy::all)]
                /// Set the timeout for receiving subsequent chunks of bytes in the Response
                /// body stream. An error return value indicates that this timeout is not
                /// supported or that this handle is immutable.
                #[allow(async_fn_in_trait)]
                pub fn set_between_bytes_timeout(
                    &self,
                    duration: Option<Duration>,
                ) -> Result<(), RequestOptionsError> {
                    unsafe {
                        #[repr(align(1))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2],
                        );
                        let (result0_0, result0_1) = match duration {
                            Some(e) => (1i32, _rt::as_i64(e)),
                            None => (0i32, 0i64),
                        };
                        let ptr1 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]request-options.set-between-bytes-timeout"]
                            fn wit_import2(_: i32, _: i32, _: i64, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import2(
                            _: i32,
                            _: i32,
                            _: i64,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import2((self).handle() as i32, result0_0, result0_1, ptr1);
                        let l3 = i32::from(*ptr1.add(0).cast::<u8>());
                        let result6 = match l3 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l4 = i32::from(*ptr1.add(1).cast::<u8>());
                                    let v5 = match l4 {
                                        0 => RequestOptionsError::NotSupported,
                                        n => {
                                            debug_assert_eq!(n, 1, "invalid enum discriminant");
                                            RequestOptionsError::Immutable
                                        }
                                    };
                                    v5
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        };
                        result6
                    }
                }
            }
            impl RequestOptions {
                #[allow(unused_unsafe, clippy::all)]
                /// Make a deep copy of the `request-options`.
                /// The resulting `request-options` is mutable.
                #[allow(async_fn_in_trait)]
                pub fn clone(&self) -> RequestOptions {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]request-options.clone"]
                            fn wit_import0(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import0(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import0((self).handle() as i32);
                        RequestOptions::from_handle(ret as u32)
                    }
                }
            }
            impl Response {
                #[allow(unused_unsafe, clippy::all)]
                /// Construct a new `response`, with a default `status-code` of `200`.
                /// If a different `status-code` is needed, it must be set via the
                /// `set-status-code` method.
                ///
                /// `headers` is the HTTP Headers for the Response.
                ///
                /// `contents` is the optional body content stream with `none`
                /// representing a zero-length content stream.
                /// Once it is closed, `trailers` future must resolve to a result.
                /// If `trailers` resolves to an error, underlying connection
                /// will be closed immediately.
                ///
                /// The returned future resolves to result of transmission of this response.
                #[allow(async_fn_in_trait)]
                pub fn new(
                    headers: Headers,
                    contents: Option<wit_bindgen::rt::async_support::StreamReader<u8>>,
                    trailers: wit_bindgen::rt::async_support::FutureReader<
                        Result<Option<Trailers>, ErrorCode>,
                    >,
                ) -> (
                    Response,
                    wit_bindgen::rt::async_support::FutureReader<Result<(), ErrorCode>>,
                ) {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 8],
                        );
                        let (result0_0, result0_1) = match &contents {
                            Some(e) => (1i32, (e).take_handle() as i32),
                            None => (0i32, 0i32),
                        };
                        let ptr1 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[static]response.new"]
                            fn wit_import2(_: i32, _: i32, _: i32, _: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import2(
                            _: i32,
                            _: i32,
                            _: i32,
                            _: i32,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import2(
                            (&headers).take_handle() as i32,
                            result0_0,
                            result0_1,
                            (&trailers).take_handle() as i32,
                            ptr1,
                        );
                        let l3 = *ptr1.add(0).cast::<i32>();
                        let l4 = *ptr1.add(4).cast::<i32>();
                        let result5 = (
                            Response::from_handle(l3 as u32),
                            wit_bindgen::rt::async_support::FutureReader::new(
                                l4 as u32,
                                &super::super::super::wit_future::vtable1::VTABLE,
                            ),
                        );
                        result5
                    }
                }
            }
            impl Response {
                #[allow(unused_unsafe, clippy::all)]
                /// Get the HTTP Status Code for the Response.
                #[allow(async_fn_in_trait)]
                pub fn get_status_code(&self) -> StatusCode {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]response.get-status-code"]
                            fn wit_import0(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import0(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import0((self).handle() as i32);
                        ret as u16
                    }
                }
            }
            impl Response {
                #[allow(unused_unsafe, clippy::all)]
                /// Set the HTTP Status Code for the Response. Fails if the status-code
                /// given is not a valid http status code.
                #[allow(async_fn_in_trait)]
                pub fn set_status_code(
                    &self,
                    status_code: StatusCode,
                ) -> Result<(), ()> {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]response.set-status-code"]
                            fn wit_import0(_: i32, _: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import0(_: i32, _: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import0(
                            (self).handle() as i32,
                            _rt::as_i32(status_code),
                        );
                        match ret {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = ();
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Response {
                #[allow(unused_unsafe, clippy::all)]
                /// Get the headers associated with the Response.
                ///
                /// The returned `headers` resource is immutable: `set`, `append`, and
                /// `delete` operations will fail with `header-error.immutable`.
                #[allow(async_fn_in_trait)]
                pub fn get_headers(&self) -> Headers {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[method]response.get-headers"]
                            fn wit_import0(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import0(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import0((self).handle() as i32);
                        Fields::from_handle(ret as u32)
                    }
                }
            }
            impl Response {
                #[allow(unused_unsafe, clippy::all)]
                /// Get body of the Response.
                ///
                /// Stream returned by this method represents the contents of the body.
                /// Once the stream is reported as closed, callers should await the returned
                /// future to determine whether the body was received successfully.
                /// The future will only resolve after the stream is reported as closed.
                ///
                /// This function takes a `res` future as a parameter, which can be used to
                /// communicate an error in handling of the response.
                ///
                /// Note that function will move the `response`, but references to headers
                /// acquired from it previously will remain valid.
                #[allow(async_fn_in_trait)]
                pub fn consume_body(
                    this: Response,
                    res: wit_bindgen::rt::async_support::FutureReader<
                        Result<(), ErrorCode>,
                    >,
                ) -> (
                    wit_bindgen::rt::async_support::StreamReader<u8>,
                    wit_bindgen::rt::async_support::FutureReader<
                        Result<Option<Trailers>, ErrorCode>,
                    >,
                ) {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 8],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(
                            wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06"
                        )]
                        unsafe extern "C" {
                            #[link_name = "[static]response.consume-body"]
                            fn wit_import1(_: i32, _: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        unsafe extern "C" fn wit_import1(_: i32, _: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import1(
                            (&this).take_handle() as i32,
                            (&res).take_handle() as i32,
                            ptr0,
                        );
                        let l2 = *ptr0.add(0).cast::<i32>();
                        let l3 = *ptr0.add(4).cast::<i32>();
                        let result4 = (
                            wit_bindgen::rt::async_support::StreamReader::new(
                                l2 as u32,
                                &super::super::super::wit_stream::vtable0::VTABLE,
                            ),
                            wit_bindgen::rt::async_support::FutureReader::new(
                                l3 as u32,
                                &super::super::super::wit_future::vtable0::VTABLE,
                            ),
                        );
                        result4
                    }
                }
            }
        }
        /// This interface defines an HTTP client for sending "outgoing" requests.
        ///
        /// Most components are expected to import this interface to provide the
        /// capability to send HTTP requests to arbitrary destinations on a network.
        ///
        /// The type signature of `client.send` is the same as `handler.handle`. This
        /// duplication is currently necessary because some Component Model tooling
        /// (including WIT itself) is unable to represent a component importing two
        /// instances of the same interface. A `client.send` import may be linked
        /// directly to a `handler.handle` export to bypass the network.
        #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)]
        pub mod client {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            use super::super::super::_rt;
            pub type Request = super::super::super::wasi::http::types::Request;
            pub type Response = super::super::super::wasi::http::types::Response;
            pub type ErrorCode = super::super::super::wasi::http::types::ErrorCode;
            #[allow(unused_unsafe, clippy::all)]
            /// This function may be used to either send an outgoing request over the
            /// network or to forward it to another component.
            #[allow(async_fn_in_trait)]
            pub async fn send(request: Request) -> Result<Response, ErrorCode> {
                unsafe {
                    #[derive(Copy, Clone)]
                    struct ParamsLower(i32);
                    unsafe impl Send for ParamsLower {}
                    use wit_bindgen::rt::async_support::Subtask as _Subtask;
                    struct _MySubtask<'a> {
                        _unused: core::marker::PhantomData<&'a ()>,
                    }
                    #[allow(unused_parens)]
                    unsafe impl<'a> _Subtask for _MySubtask<'a> {
                        type Params = (Request,);
                        type Results = Result<Response, ErrorCode>;
                        type ParamsLower = ParamsLower;
                        fn abi_layout(&mut self) -> ::core::alloc::Layout {
                            unsafe {
                                ::core::alloc::Layout::from_size_align_unchecked(
                                    (24 + 4 * ::core::mem::size_of::<*const u8>()),
                                    8,
                                )
                            }
                        }
                        fn results_offset(&mut self) -> usize {
                            0
                        }
                        unsafe fn call_import(
                            &mut self,
                            _params: Self::ParamsLower,
                            _results: *mut u8,
                        ) -> u32 {
                            #[cfg(target_arch = "wasm32")]
                            #[link(
                                wasm_import_module = "wasi:http/client@0.3.0-rc-2026-01-06"
                            )]
                            unsafe extern "C" {
                                #[link_name = "[async-lower]send"]
                                fn call(_: i32, _: *mut u8) -> i32;
                            }
                            #[cfg(not(target_arch = "wasm32"))]
                            unsafe extern "C" fn call(_: i32, _: *mut u8) -> i32 {
                                unreachable!()
                            }
                            unsafe { call(_params.0, _results) as u32 }
                        }
                        unsafe fn params_dealloc_lists(
                            &mut self,
                            _params: Self::ParamsLower,
                        ) {
                            unsafe {}
                        }
                        unsafe fn params_dealloc_lists_and_own(
                            &mut self,
                            _params: Self::ParamsLower,
                        ) {
                            unsafe {
                                let _ = super::super::super::wasi::http::types::Request::from_handle(
                                    _params.0 as u32,
                                );
                            }
                        }
                        unsafe fn params_lower(
                            &mut self,
                            (_lower0,): Self::Params,
                            _ptr: *mut u8,
                        ) -> Self::ParamsLower {
                            unsafe { ParamsLower((_lower0).take_handle() as i32) }
                        }
                        unsafe fn results_lift(
                            &mut self,
                            _ptr: *mut u8,
                        ) -> Self::Results {
                            unsafe {
                                let l0 = i32::from(*_ptr.add(0).cast::<u8>());
                                match l0 {
                                    0 => {
                                        let e = {
                                            let l1 = *_ptr.add(8).cast::<i32>();
                                            super::super::super::wasi::http::types::Response::from_handle(
                                                l1 as u32,
                                            )
                                        };
                                        Ok(e)
                                    }
                                    1 => {
                                        let e = {
                                            let l2 = i32::from(*_ptr.add(8).cast::<u8>());
                                            use super::super::super::wasi::http::types::ErrorCode as V64;
                                            let v64 = match l2 {
                                                0 => V64::DnsTimeout,
                                                1 => {
                                                    let e64 = {
                                                        let l3 = i32::from(*_ptr.add(16).cast::<u8>());
                                                        let l7 = i32::from(
                                                            *_ptr
                                                                .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                                .cast::<u8>(),
                                                        );
                                                        super::super::super::wasi::http::types::DnsErrorPayload {
                                                            rcode: match l3 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l4 = *_ptr
                                                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                                            .cast::<*mut u8>();
                                                                        let l5 = *_ptr
                                                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                                            .cast::<usize>();
                                                                        let len6 = l5;
                                                                        let bytes6 = _rt::Vec::from_raw_parts(
                                                                            l4.cast(),
                                                                            len6,
                                                                            len6,
                                                                        );
                                                                        _rt::string_lift(bytes6)
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                            info_code: match l7 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l8 = i32::from(
                                                                            *_ptr
                                                                                .add(18 + 3 * ::core::mem::size_of::<*const u8>())
                                                                                .cast::<u16>(),
                                                                        );
                                                                        l8 as u16
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                        }
                                                    };
                                                    V64::DnsError(e64)
                                                }
                                                2 => V64::DestinationNotFound,
                                                3 => V64::DestinationUnavailable,
                                                4 => V64::DestinationIpProhibited,
                                                5 => V64::DestinationIpUnroutable,
                                                6 => V64::ConnectionRefused,
                                                7 => V64::ConnectionTerminated,
                                                8 => V64::ConnectionTimeout,
                                                9 => V64::ConnectionReadTimeout,
                                                10 => V64::ConnectionWriteTimeout,
                                                11 => V64::ConnectionLimitReached,
                                                12 => V64::TlsProtocolError,
                                                13 => V64::TlsCertificateError,
                                                14 => {
                                                    let e64 = {
                                                        let l9 = i32::from(*_ptr.add(16).cast::<u8>());
                                                        let l11 = i32::from(
                                                            *_ptr
                                                                .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                                .cast::<u8>(),
                                                        );
                                                        super::super::super::wasi::http::types::TlsAlertReceivedPayload {
                                                            alert_id: match l9 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l10 = i32::from(*_ptr.add(17).cast::<u8>());
                                                                        l10 as u8
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                            alert_message: match l11 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l12 = *_ptr
                                                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                                            .cast::<*mut u8>();
                                                                        let l13 = *_ptr
                                                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                                            .cast::<usize>();
                                                                        let len14 = l13;
                                                                        let bytes14 = _rt::Vec::from_raw_parts(
                                                                            l12.cast(),
                                                                            len14,
                                                                            len14,
                                                                        );
                                                                        _rt::string_lift(bytes14)
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                        }
                                                    };
                                                    V64::TlsAlertReceived(e64)
                                                }
                                                15 => V64::HttpRequestDenied,
                                                16 => V64::HttpRequestLengthRequired,
                                                17 => {
                                                    let e64 = {
                                                        let l15 = i32::from(*_ptr.add(16).cast::<u8>());
                                                        match l15 {
                                                            0 => None,
                                                            1 => {
                                                                let e = {
                                                                    let l16 = *_ptr.add(24).cast::<i64>();
                                                                    l16 as u64
                                                                };
                                                                Some(e)
                                                            }
                                                            _ => _rt::invalid_enum_discriminant(),
                                                        }
                                                    };
                                                    V64::HttpRequestBodySize(e64)
                                                }
                                                18 => V64::HttpRequestMethodInvalid,
                                                19 => V64::HttpRequestUriInvalid,
                                                20 => V64::HttpRequestUriTooLong,
                                                21 => {
                                                    let e64 = {
                                                        let l17 = i32::from(*_ptr.add(16).cast::<u8>());
                                                        match l17 {
                                                            0 => None,
                                                            1 => {
                                                                let e = {
                                                                    let l18 = *_ptr.add(20).cast::<i32>();
                                                                    l18 as u32
                                                                };
                                                                Some(e)
                                                            }
                                                            _ => _rt::invalid_enum_discriminant(),
                                                        }
                                                    };
                                                    V64::HttpRequestHeaderSectionSize(e64)
                                                }
                                                22 => {
                                                    let e64 = {
                                                        let l19 = i32::from(*_ptr.add(16).cast::<u8>());
                                                        match l19 {
                                                            0 => None,
                                                            1 => {
                                                                let e = {
                                                                    let l20 = i32::from(
                                                                        *_ptr
                                                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                                            .cast::<u8>(),
                                                                    );
                                                                    let l24 = i32::from(
                                                                        *_ptr
                                                                            .add(16 + 4 * ::core::mem::size_of::<*const u8>())
                                                                            .cast::<u8>(),
                                                                    );
                                                                    super::super::super::wasi::http::types::FieldSizePayload {
                                                                        field_name: match l20 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l21 = *_ptr
                                                                                        .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                                                        .cast::<*mut u8>();
                                                                                    let l22 = *_ptr
                                                                                        .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                                                        .cast::<usize>();
                                                                                    let len23 = l22;
                                                                                    let bytes23 = _rt::Vec::from_raw_parts(
                                                                                        l21.cast(),
                                                                                        len23,
                                                                                        len23,
                                                                                    );
                                                                                    _rt::string_lift(bytes23)
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        },
                                                                        field_size: match l24 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l25 = *_ptr
                                                                                        .add(20 + 4 * ::core::mem::size_of::<*const u8>())
                                                                                        .cast::<i32>();
                                                                                    l25 as u32
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        },
                                                                    }
                                                                };
                                                                Some(e)
                                                            }
                                                            _ => _rt::invalid_enum_discriminant(),
                                                        }
                                                    };
                                                    V64::HttpRequestHeaderSize(e64)
                                                }
                                                23 => {
                                                    let e64 = {
                                                        let l26 = i32::from(*_ptr.add(16).cast::<u8>());
                                                        match l26 {
                                                            0 => None,
                                                            1 => {
                                                                let e = {
                                                                    let l27 = *_ptr.add(20).cast::<i32>();
                                                                    l27 as u32
                                                                };
                                                                Some(e)
                                                            }
                                                            _ => _rt::invalid_enum_discriminant(),
                                                        }
                                                    };
                                                    V64::HttpRequestTrailerSectionSize(e64)
                                                }
                                                24 => {
                                                    let e64 = {
                                                        let l28 = i32::from(*_ptr.add(16).cast::<u8>());
                                                        let l32 = i32::from(
                                                            *_ptr
                                                                .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                                .cast::<u8>(),
                                                        );
                                                        super::super::super::wasi::http::types::FieldSizePayload {
                                                            field_name: match l28 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l29 = *_ptr
                                                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                                            .cast::<*mut u8>();
                                                                        let l30 = *_ptr
                                                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                                            .cast::<usize>();
                                                                        let len31 = l30;
                                                                        let bytes31 = _rt::Vec::from_raw_parts(
                                                                            l29.cast(),
                                                                            len31,
                                                                            len31,
                                                                        );
                                                                        _rt::string_lift(bytes31)
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                            field_size: match l32 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l33 = *_ptr
                                                                            .add(20 + 3 * ::core::mem::size_of::<*const u8>())
                                                                            .cast::<i32>();
                                                                        l33 as u32
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                        }
                                                    };
                                                    V64::HttpRequestTrailerSize(e64)
                                                }
                                                25 => V64::HttpResponseIncomplete,
                                                26 => {
                                                    let e64 = {
                                                        let l34 = i32::from(*_ptr.add(16).cast::<u8>());
                                                        match l34 {
                                                            0 => None,
                                                            1 => {
                                                                let e = {
                                                                    let l35 = *_ptr.add(20).cast::<i32>();
                                                                    l35 as u32
                                                                };
                                                                Some(e)
                                                            }
                                                            _ => _rt::invalid_enum_discriminant(),
                                                        }
                                                    };
                                                    V64::HttpResponseHeaderSectionSize(e64)
                                                }
                                                27 => {
                                                    let e64 = {
                                                        let l36 = i32::from(*_ptr.add(16).cast::<u8>());
                                                        let l40 = i32::from(
                                                            *_ptr
                                                                .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                                .cast::<u8>(),
                                                        );
                                                        super::super::super::wasi::http::types::FieldSizePayload {
                                                            field_name: match l36 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l37 = *_ptr
                                                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                                            .cast::<*mut u8>();
                                                                        let l38 = *_ptr
                                                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                                            .cast::<usize>();
                                                                        let len39 = l38;
                                                                        let bytes39 = _rt::Vec::from_raw_parts(
                                                                            l37.cast(),
                                                                            len39,
                                                                            len39,
                                                                        );
                                                                        _rt::string_lift(bytes39)
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                            field_size: match l40 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l41 = *_ptr
                                                                            .add(20 + 3 * ::core::mem::size_of::<*const u8>())
                                                                            .cast::<i32>();
                                                                        l41 as u32
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                        }
                                                    };
                                                    V64::HttpResponseHeaderSize(e64)
                                                }
                                                28 => {
                                                    let e64 = {
                                                        let l42 = i32::from(*_ptr.add(16).cast::<u8>());
                                                        match l42 {
                                                            0 => None,
                                                            1 => {
                                                                let e = {
                                                                    let l43 = *_ptr.add(24).cast::<i64>();
                                                                    l43 as u64
                                                                };
                                                                Some(e)
                                                            }
                                                            _ => _rt::invalid_enum_discriminant(),
                                                        }
                                                    };
                                                    V64::HttpResponseBodySize(e64)
                                                }
                                                29 => {
                                                    let e64 = {
                                                        let l44 = i32::from(*_ptr.add(16).cast::<u8>());
                                                        match l44 {
                                                            0 => None,
                                                            1 => {
                                                                let e = {
                                                                    let l45 = *_ptr.add(20).cast::<i32>();
                                                                    l45 as u32
                                                                };
                                                                Some(e)
                                                            }
                                                            _ => _rt::invalid_enum_discriminant(),
                                                        }
                                                    };
                                                    V64::HttpResponseTrailerSectionSize(e64)
                                                }
                                                30 => {
                                                    let e64 = {
                                                        let l46 = i32::from(*_ptr.add(16).cast::<u8>());
                                                        let l50 = i32::from(
                                                            *_ptr
                                                                .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                                .cast::<u8>(),
                                                        );
                                                        super::super::super::wasi::http::types::FieldSizePayload {
                                                            field_name: match l46 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l47 = *_ptr
                                                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                                            .cast::<*mut u8>();
                                                                        let l48 = *_ptr
                                                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                                            .cast::<usize>();
                                                                        let len49 = l48;
                                                                        let bytes49 = _rt::Vec::from_raw_parts(
                                                                            l47.cast(),
                                                                            len49,
                                                                            len49,
                                                                        );
                                                                        _rt::string_lift(bytes49)
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                            field_size: match l50 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l51 = *_ptr
                                                                            .add(20 + 3 * ::core::mem::size_of::<*const u8>())
                                                                            .cast::<i32>();
                                                                        l51 as u32
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                        }
                                                    };
                                                    V64::HttpResponseTrailerSize(e64)
                                                }
                                                31 => {
                                                    let e64 = {
                                                        let l52 = i32::from(*_ptr.add(16).cast::<u8>());
                                                        match l52 {
                                                            0 => None,
                                                            1 => {
                                                                let e = {
                                                                    let l53 = *_ptr
                                                                        .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                                        .cast::<*mut u8>();
                                                                    let l54 = *_ptr
                                                                        .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                                        .cast::<usize>();
                                                                    let len55 = l54;
                                                                    let bytes55 = _rt::Vec::from_raw_parts(
                                                                        l53.cast(),
                                                                        len55,
                                                                        len55,
                                                                    );
                                                                    _rt::string_lift(bytes55)
                                                                };
                                                                Some(e)
                                                            }
                                                            _ => _rt::invalid_enum_discriminant(),
                                                        }
                                                    };
                                                    V64::HttpResponseTransferCoding(e64)
                                                }
                                                32 => {
                                                    let e64 = {
                                                        let l56 = i32::from(*_ptr.add(16).cast::<u8>());
                                                        match l56 {
                                                            0 => None,
                                                            1 => {
                                                                let e = {
                                                                    let l57 = *_ptr
                                                                        .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                                        .cast::<*mut u8>();
                                                                    let l58 = *_ptr
                                                                        .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                                        .cast::<usize>();
                                                                    let len59 = l58;
                                                                    let bytes59 = _rt::Vec::from_raw_parts(
                                                                        l57.cast(),
                                                                        len59,
                                                                        len59,
                                                                    );
                                                                    _rt::string_lift(bytes59)
                                                                };
                                                                Some(e)
                                                            }
                                                            _ => _rt::invalid_enum_discriminant(),
                                                        }
                                                    };
                                                    V64::HttpResponseContentCoding(e64)
                                                }
                                                33 => V64::HttpResponseTimeout,
                                                34 => V64::HttpUpgradeFailed,
                                                35 => V64::HttpProtocolError,
                                                36 => V64::LoopDetected,
                                                37 => V64::ConfigurationError,
                                                n => {
                                                    debug_assert_eq!(n, 38, "invalid enum discriminant");
                                                    let e64 = {
                                                        let l60 = i32::from(*_ptr.add(16).cast::<u8>());
                                                        match l60 {
                                                            0 => None,
                                                            1 => {
                                                                let e = {
                                                                    let l61 = *_ptr
                                                                        .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                                        .cast::<*mut u8>();
                                                                    let l62 = *_ptr
                                                                        .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                                        .cast::<usize>();
                                                                    let len63 = l62;
                                                                    let bytes63 = _rt::Vec::from_raw_parts(
                                                                        l61.cast(),
                                                                        len63,
                                                                        len63,
                                                                    );
                                                                    _rt::string_lift(bytes63)
                                                                };
                                                                Some(e)
                                                            }
                                                            _ => _rt::invalid_enum_discriminant(),
                                                        }
                                                    };
                                                    V64::InternalError(e64)
                                                }
                                            };
                                            v64
                                        };
                                        Err(e)
                                    }
                                    _ => _rt::invalid_enum_discriminant(),
                                }
                            }
                        }
                    }
                    _MySubtask {
                        _unused: core::marker::PhantomData,
                    }
                        .call((request,))
                        .await
                }
            }
        }
    }
}
#[rustfmt::skip]
#[allow(dead_code, clippy::all)]
pub mod exports {
    pub mod wasi {
        pub mod http {
            /// This interface defines a handler of HTTP Requests.
            ///
            /// In a `wasi:http/service` this interface is exported to respond to an
            /// incoming HTTP Request with a Response.
            ///
            /// In `wasi:http/middleware` this interface is both exported and imported as
            /// the "downstream" and "upstream" directions of the middleware chain.
            #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)]
            pub mod handler {
                #[used]
                #[doc(hidden)]
                static __FORCE_SECTION_REF: fn() = super::super::super::super::__link_custom_section_describing_imports;
                use super::super::super::super::_rt;
                pub type Request = super::super::super::super::wasi::http::types::Request;
                pub type Response = super::super::super::super::wasi::http::types::Response;
                pub type ErrorCode = super::super::super::super::wasi::http::types::ErrorCode;
                #[doc(hidden)]
                #[allow(non_snake_case, unused_unsafe)]
                pub unsafe fn _export_handle_cabi<T: Guest>(arg0: i32) -> i32 {
                    unsafe {
                        #[cfg(target_arch = "wasm32")] _rt::run_ctors_once();
                        wit_bindgen::rt::async_support::start_task(async move {
                            let _task_cancel = wit_bindgen::rt::async_support::TaskCancelOnDrop::new();
                            let result0 = &{
                                T::handle(
                                        super::super::super::super::wasi::http::types::Request::from_handle(
                                            arg0 as u32,
                                        ),
                                    )
                                    .await
                            };
                            let (
                                result40_0,
                                result40_1,
                                result40_2,
                                result40_3,
                                result40_4,
                                result40_5,
                                result40_6,
                                result40_7,
                            ) = match result0 {
                                Ok(e) => {
                                    (
                                        0i32,
                                        (e).take_handle() as i32,
                                        0i32,
                                        ::core::mem::MaybeUninit::<u64>::zeroed(),
                                        ::core::ptr::null_mut(),
                                        ::core::ptr::null_mut(),
                                        0usize,
                                        0i32,
                                    )
                                }
                                Err(e) => {
                                    use super::super::super::super::wasi::http::types::ErrorCode as V38;
                                    let (
                                        result39_0,
                                        result39_1,
                                        result39_2,
                                        result39_3,
                                        result39_4,
                                        result39_5,
                                        result39_6,
                                    ) = match e {
                                        V38::DnsTimeout => {
                                            (
                                                0i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::DnsError(e) => {
                                            let super::super::super::super::wasi::http::types::DnsErrorPayload {
                                                rcode: rcode1,
                                                info_code: info_code1,
                                            } = e;
                                            let (result3_0, result3_1, result3_2) = match rcode1 {
                                                Some(e) => {
                                                    let vec2 = e;
                                                    let ptr2 = vec2.as_ptr().cast::<u8>();
                                                    let len2 = vec2.len();
                                                    (1i32, ptr2.cast_mut(), len2)
                                                }
                                                None => (0i32, ::core::ptr::null_mut(), 0usize),
                                            };
                                            let (result4_0, result4_1) = match info_code1 {
                                                Some(e) => (1i32, _rt::as_i32(e)),
                                                None => (0i32, 0i32),
                                            };
                                            (
                                                1i32,
                                                result3_0,
                                                {
                                                    let mut t = ::core::mem::MaybeUninit::<u64>::uninit();
                                                    t.as_mut_ptr().cast::<*mut u8>().write(result3_1);
                                                    t
                                                },
                                                result3_2 as *mut u8,
                                                result4_0 as *mut u8,
                                                result4_1 as usize,
                                                0i32,
                                            )
                                        }
                                        V38::DestinationNotFound => {
                                            (
                                                2i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::DestinationUnavailable => {
                                            (
                                                3i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::DestinationIpProhibited => {
                                            (
                                                4i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::DestinationIpUnroutable => {
                                            (
                                                5i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::ConnectionRefused => {
                                            (
                                                6i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::ConnectionTerminated => {
                                            (
                                                7i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::ConnectionTimeout => {
                                            (
                                                8i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::ConnectionReadTimeout => {
                                            (
                                                9i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::ConnectionWriteTimeout => {
                                            (
                                                10i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::ConnectionLimitReached => {
                                            (
                                                11i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::TlsProtocolError => {
                                            (
                                                12i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::TlsCertificateError => {
                                            (
                                                13i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::TlsAlertReceived(e) => {
                                            let super::super::super::super::wasi::http::types::TlsAlertReceivedPayload {
                                                alert_id: alert_id5,
                                                alert_message: alert_message5,
                                            } = e;
                                            let (result6_0, result6_1) = match alert_id5 {
                                                Some(e) => (1i32, _rt::as_i32(e)),
                                                None => (0i32, 0i32),
                                            };
                                            let (result8_0, result8_1, result8_2) = match alert_message5 {
                                                Some(e) => {
                                                    let vec7 = e;
                                                    let ptr7 = vec7.as_ptr().cast::<u8>();
                                                    let len7 = vec7.len();
                                                    (1i32, ptr7.cast_mut(), len7)
                                                }
                                                None => (0i32, ::core::ptr::null_mut(), 0usize),
                                            };
                                            (
                                                14i32,
                                                result6_0,
                                                ::core::mem::MaybeUninit::new(i64::from(result6_1) as u64),
                                                result8_0 as *mut u8,
                                                result8_1,
                                                result8_2,
                                                0i32,
                                            )
                                        }
                                        V38::HttpRequestDenied => {
                                            (
                                                15i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::HttpRequestLengthRequired => {
                                            (
                                                16i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::HttpRequestBodySize(e) => {
                                            let (result9_0, result9_1) = match e {
                                                Some(e) => (1i32, _rt::as_i64(e)),
                                                None => (0i32, 0i64),
                                            };
                                            (
                                                17i32,
                                                result9_0,
                                                ::core::mem::MaybeUninit::new(result9_1 as u64),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::HttpRequestMethodInvalid => {
                                            (
                                                18i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::HttpRequestUriInvalid => {
                                            (
                                                19i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::HttpRequestUriTooLong => {
                                            (
                                                20i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::HttpRequestHeaderSectionSize(e) => {
                                            let (result10_0, result10_1) = match e {
                                                Some(e) => (1i32, _rt::as_i32(e)),
                                                None => (0i32, 0i32),
                                            };
                                            (
                                                21i32,
                                                result10_0,
                                                ::core::mem::MaybeUninit::new(i64::from(result10_1) as u64),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::HttpRequestHeaderSize(e) => {
                                            let (
                                                result15_0,
                                                result15_1,
                                                result15_2,
                                                result15_3,
                                                result15_4,
                                                result15_5,
                                            ) = match e {
                                                Some(e) => {
                                                    let super::super::super::super::wasi::http::types::FieldSizePayload {
                                                        field_name: field_name11,
                                                        field_size: field_size11,
                                                    } = e;
                                                    let (result13_0, result13_1, result13_2) = match field_name11 {
                                                        Some(e) => {
                                                            let vec12 = e;
                                                            let ptr12 = vec12.as_ptr().cast::<u8>();
                                                            let len12 = vec12.len();
                                                            (1i32, ptr12.cast_mut(), len12)
                                                        }
                                                        None => (0i32, ::core::ptr::null_mut(), 0usize),
                                                    };
                                                    let (result14_0, result14_1) = match field_size11 {
                                                        Some(e) => (1i32, _rt::as_i32(e)),
                                                        None => (0i32, 0i32),
                                                    };
                                                    (
                                                        1i32,
                                                        result13_0,
                                                        result13_1,
                                                        result13_2,
                                                        result14_0,
                                                        result14_1,
                                                    )
                                                }
                                                None => {
                                                    (0i32, 0i32, ::core::ptr::null_mut(), 0usize, 0i32, 0i32)
                                                }
                                            };
                                            (
                                                22i32,
                                                result15_0,
                                                ::core::mem::MaybeUninit::new(i64::from(result15_1) as u64),
                                                result15_2,
                                                result15_3 as *mut u8,
                                                result15_4 as usize,
                                                result15_5,
                                            )
                                        }
                                        V38::HttpRequestTrailerSectionSize(e) => {
                                            let (result16_0, result16_1) = match e {
                                                Some(e) => (1i32, _rt::as_i32(e)),
                                                None => (0i32, 0i32),
                                            };
                                            (
                                                23i32,
                                                result16_0,
                                                ::core::mem::MaybeUninit::new(i64::from(result16_1) as u64),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::HttpRequestTrailerSize(e) => {
                                            let super::super::super::super::wasi::http::types::FieldSizePayload {
                                                field_name: field_name17,
                                                field_size: field_size17,
                                            } = e;
                                            let (result19_0, result19_1, result19_2) = match field_name17 {
                                                Some(e) => {
                                                    let vec18 = e;
                                                    let ptr18 = vec18.as_ptr().cast::<u8>();
                                                    let len18 = vec18.len();
                                                    (1i32, ptr18.cast_mut(), len18)
                                                }
                                                None => (0i32, ::core::ptr::null_mut(), 0usize),
                                            };
                                            let (result20_0, result20_1) = match field_size17 {
                                                Some(e) => (1i32, _rt::as_i32(e)),
                                                None => (0i32, 0i32),
                                            };
                                            (
                                                24i32,
                                                result19_0,
                                                {
                                                    let mut t = ::core::mem::MaybeUninit::<u64>::uninit();
                                                    t.as_mut_ptr().cast::<*mut u8>().write(result19_1);
                                                    t
                                                },
                                                result19_2 as *mut u8,
                                                result20_0 as *mut u8,
                                                result20_1 as usize,
                                                0i32,
                                            )
                                        }
                                        V38::HttpResponseIncomplete => {
                                            (
                                                25i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::HttpResponseHeaderSectionSize(e) => {
                                            let (result21_0, result21_1) = match e {
                                                Some(e) => (1i32, _rt::as_i32(e)),
                                                None => (0i32, 0i32),
                                            };
                                            (
                                                26i32,
                                                result21_0,
                                                ::core::mem::MaybeUninit::new(i64::from(result21_1) as u64),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::HttpResponseHeaderSize(e) => {
                                            let super::super::super::super::wasi::http::types::FieldSizePayload {
                                                field_name: field_name22,
                                                field_size: field_size22,
                                            } = e;
                                            let (result24_0, result24_1, result24_2) = match field_name22 {
                                                Some(e) => {
                                                    let vec23 = e;
                                                    let ptr23 = vec23.as_ptr().cast::<u8>();
                                                    let len23 = vec23.len();
                                                    (1i32, ptr23.cast_mut(), len23)
                                                }
                                                None => (0i32, ::core::ptr::null_mut(), 0usize),
                                            };
                                            let (result25_0, result25_1) = match field_size22 {
                                                Some(e) => (1i32, _rt::as_i32(e)),
                                                None => (0i32, 0i32),
                                            };
                                            (
                                                27i32,
                                                result24_0,
                                                {
                                                    let mut t = ::core::mem::MaybeUninit::<u64>::uninit();
                                                    t.as_mut_ptr().cast::<*mut u8>().write(result24_1);
                                                    t
                                                },
                                                result24_2 as *mut u8,
                                                result25_0 as *mut u8,
                                                result25_1 as usize,
                                                0i32,
                                            )
                                        }
                                        V38::HttpResponseBodySize(e) => {
                                            let (result26_0, result26_1) = match e {
                                                Some(e) => (1i32, _rt::as_i64(e)),
                                                None => (0i32, 0i64),
                                            };
                                            (
                                                28i32,
                                                result26_0,
                                                ::core::mem::MaybeUninit::new(result26_1 as u64),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::HttpResponseTrailerSectionSize(e) => {
                                            let (result27_0, result27_1) = match e {
                                                Some(e) => (1i32, _rt::as_i32(e)),
                                                None => (0i32, 0i32),
                                            };
                                            (
                                                29i32,
                                                result27_0,
                                                ::core::mem::MaybeUninit::new(i64::from(result27_1) as u64),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::HttpResponseTrailerSize(e) => {
                                            let super::super::super::super::wasi::http::types::FieldSizePayload {
                                                field_name: field_name28,
                                                field_size: field_size28,
                                            } = e;
                                            let (result30_0, result30_1, result30_2) = match field_name28 {
                                                Some(e) => {
                                                    let vec29 = e;
                                                    let ptr29 = vec29.as_ptr().cast::<u8>();
                                                    let len29 = vec29.len();
                                                    (1i32, ptr29.cast_mut(), len29)
                                                }
                                                None => (0i32, ::core::ptr::null_mut(), 0usize),
                                            };
                                            let (result31_0, result31_1) = match field_size28 {
                                                Some(e) => (1i32, _rt::as_i32(e)),
                                                None => (0i32, 0i32),
                                            };
                                            (
                                                30i32,
                                                result30_0,
                                                {
                                                    let mut t = ::core::mem::MaybeUninit::<u64>::uninit();
                                                    t.as_mut_ptr().cast::<*mut u8>().write(result30_1);
                                                    t
                                                },
                                                result30_2 as *mut u8,
                                                result31_0 as *mut u8,
                                                result31_1 as usize,
                                                0i32,
                                            )
                                        }
                                        V38::HttpResponseTransferCoding(e) => {
                                            let (result33_0, result33_1, result33_2) = match e {
                                                Some(e) => {
                                                    let vec32 = e;
                                                    let ptr32 = vec32.as_ptr().cast::<u8>();
                                                    let len32 = vec32.len();
                                                    (1i32, ptr32.cast_mut(), len32)
                                                }
                                                None => (0i32, ::core::ptr::null_mut(), 0usize),
                                            };
                                            (
                                                31i32,
                                                result33_0,
                                                {
                                                    let mut t = ::core::mem::MaybeUninit::<u64>::uninit();
                                                    t.as_mut_ptr().cast::<*mut u8>().write(result33_1);
                                                    t
                                                },
                                                result33_2 as *mut u8,
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::HttpResponseContentCoding(e) => {
                                            let (result35_0, result35_1, result35_2) = match e {
                                                Some(e) => {
                                                    let vec34 = e;
                                                    let ptr34 = vec34.as_ptr().cast::<u8>();
                                                    let len34 = vec34.len();
                                                    (1i32, ptr34.cast_mut(), len34)
                                                }
                                                None => (0i32, ::core::ptr::null_mut(), 0usize),
                                            };
                                            (
                                                32i32,
                                                result35_0,
                                                {
                                                    let mut t = ::core::mem::MaybeUninit::<u64>::uninit();
                                                    t.as_mut_ptr().cast::<*mut u8>().write(result35_1);
                                                    t
                                                },
                                                result35_2 as *mut u8,
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::HttpResponseTimeout => {
                                            (
                                                33i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::HttpUpgradeFailed => {
                                            (
                                                34i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::HttpProtocolError => {
                                            (
                                                35i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::LoopDetected => {
                                            (
                                                36i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::ConfigurationError => {
                                            (
                                                37i32,
                                                0i32,
                                                ::core::mem::MaybeUninit::<u64>::zeroed(),
                                                ::core::ptr::null_mut(),
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                        V38::InternalError(e) => {
                                            let (result37_0, result37_1, result37_2) = match e {
                                                Some(e) => {
                                                    let vec36 = e;
                                                    let ptr36 = vec36.as_ptr().cast::<u8>();
                                                    let len36 = vec36.len();
                                                    (1i32, ptr36.cast_mut(), len36)
                                                }
                                                None => (0i32, ::core::ptr::null_mut(), 0usize),
                                            };
                                            (
                                                38i32,
                                                result37_0,
                                                {
                                                    let mut t = ::core::mem::MaybeUninit::<u64>::uninit();
                                                    t.as_mut_ptr().cast::<*mut u8>().write(result37_1);
                                                    t
                                                },
                                                result37_2 as *mut u8,
                                                ::core::ptr::null_mut(),
                                                0usize,
                                                0i32,
                                            )
                                        }
                                    };
                                    (
                                        1i32,
                                        result39_0,
                                        result39_1,
                                        result39_2,
                                        result39_3,
                                        result39_4,
                                        result39_5,
                                        result39_6,
                                    )
                                }
                            };
                            #[cfg(target_arch = "wasm32")]
                            #[link(
                                wasm_import_module = "[export]wasi:http/handler@0.3.0-rc-2026-01-06"
                            )]
                            unsafe extern "C" {
                                #[link_name = "[task-return]handle"]
                                fn wit_import41(
                                    _: i32,
                                    _: i32,
                                    _: i32,
                                    _: ::core::mem::MaybeUninit<u64>,
                                    _: *mut u8,
                                    _: *mut u8,
                                    _: usize,
                                    _: i32,
                                );
                            }
                            #[cfg(not(target_arch = "wasm32"))]
                            unsafe extern "C" fn wit_import41(
                                _: i32,
                                _: i32,
                                _: i32,
                                _: ::core::mem::MaybeUninit<u64>,
                                _: *mut u8,
                                _: *mut u8,
                                _: usize,
                                _: i32,
                            ) {
                                unreachable!()
                            }
                            _task_cancel.forget();
                            wit_import41(
                                result40_0,
                                result40_1,
                                result40_2,
                                result40_3,
                                result40_4,
                                result40_5,
                                result40_6,
                                result40_7,
                            );
                        })
                    }
                }
                #[doc(hidden)]
                #[allow(non_snake_case)]
                pub unsafe fn __callback_handle(
                    event0: u32,
                    event1: u32,
                    event2: u32,
                ) -> u32 {
                    unsafe {
                        wit_bindgen::rt::async_support::callback(event0, event1, event2)
                    }
                }
                pub trait Guest {
                    /// This function may be called with either an incoming request read from the
                    /// network or a request synthesized or forwarded by another component.
                    #[allow(async_fn_in_trait)]
                    async fn handle(request: Request) -> Result<Response, ErrorCode>;
                }
                #[doc(hidden)]
                #[macro_export]
                macro_rules! __export_wasi_http_handler_0_3_0_rc_2026_01_06_cabi {
                    ($ty:ident with_types_in $($path_to_types:tt)*) => {
                        const _ : () = { #[unsafe (export_name =
                        "[async-lift]wasi:http/handler@0.3.0-rc-2026-01-06#handle")]
                        unsafe extern "C" fn export_handle(arg0 : i32,) -> i32 { unsafe {
                        $($path_to_types)*:: _export_handle_cabi::<$ty > (arg0) } }
                        #[unsafe (export_name =
                        "[callback][async-lift]wasi:http/handler@0.3.0-rc-2026-01-06#handle")]
                        unsafe extern "C" fn _callback_handle(event0 : u32, event1 : u32,
                        event2 : u32) -> u32 { unsafe { $($path_to_types)*::
                        __callback_handle(event0, event1, event2) } } };
                    };
                }
                #[doc(hidden)]
                pub use __export_wasi_http_handler_0_3_0_rc_2026_01_06_cabi;
            }
        }
    }
}
#[rustfmt::skip]
mod _rt {
    #![allow(dead_code, unused_imports, clippy::all)]
    pub use alloc_crate::string::String;
    pub use alloc_crate::vec::Vec;
    use core::fmt;
    use core::marker;
    use core::sync::atomic::{AtomicU32, Ordering::Relaxed};
    /// A type which represents a component model resource, either imported or
    /// exported into this component.
    ///
    /// This is a low-level wrapper which handles the lifetime of the resource
    /// (namely this has a destructor). The `T` provided defines the component model
    /// intrinsics that this wrapper uses.
    ///
    /// One of the chief purposes of this type is to provide `Deref` implementations
    /// to access the underlying data when it is owned.
    ///
    /// This type is primarily used in generated code for exported and imported
    /// resources.
    #[repr(transparent)]
    pub struct Resource<T: WasmResource> {
        handle: AtomicU32,
        _marker: marker::PhantomData<T>,
    }
    /// A trait which all wasm resources implement, namely providing the ability to
    /// drop a resource.
    ///
    /// This generally is implemented by generated code, not user-facing code.
    #[allow(clippy::missing_safety_doc)]
    pub unsafe trait WasmResource {
        /// Invokes the `[resource-drop]...` intrinsic.
        unsafe fn drop(handle: u32);
    }
    impl<T: WasmResource> Resource<T> {
        #[doc(hidden)]
        pub unsafe fn from_handle(handle: u32) -> Self {
            debug_assert!(handle != 0 && handle != u32::MAX);
            Self {
                handle: AtomicU32::new(handle),
                _marker: marker::PhantomData,
            }
        }
        /// Takes ownership of the handle owned by `resource`.
        ///
        /// Note that this ideally would be `into_handle` taking `Resource<T>` by
        /// ownership. The code generator does not enable that in all situations,
        /// unfortunately, so this is provided instead.
        ///
        /// Also note that `take_handle` is in theory only ever called on values
        /// owned by a generated function. For example a generated function might
        /// take `Resource<T>` as an argument but then call `take_handle` on a
        /// reference to that argument. In that sense the dynamic nature of
        /// `take_handle` should only be exposed internally to generated code, not
        /// to user code.
        #[doc(hidden)]
        pub fn take_handle(resource: &Resource<T>) -> u32 {
            resource.handle.swap(u32::MAX, Relaxed)
        }
        #[doc(hidden)]
        pub fn handle(resource: &Resource<T>) -> u32 {
            resource.handle.load(Relaxed)
        }
    }
    impl<T: WasmResource> fmt::Debug for Resource<T> {
        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
            f.debug_struct("Resource").field("handle", &self.handle).finish()
        }
    }
    impl<T: WasmResource> Drop for Resource<T> {
        fn drop(&mut self) {
            unsafe {
                match self.handle.load(Relaxed) {
                    u32::MAX => {}
                    other => T::drop(other),
                }
            }
        }
    }
    pub use alloc_crate::alloc;
    pub unsafe fn invalid_enum_discriminant<T>() -> T {
        if cfg!(debug_assertions) {
            panic!("invalid enum discriminant")
        } else {
            unsafe { core::hint::unreachable_unchecked() }
        }
    }
    pub unsafe fn cabi_dealloc(ptr: *mut u8, size: usize, align: usize) {
        if size == 0 {
            return;
        }
        unsafe {
            let layout = alloc::Layout::from_size_align_unchecked(size, align);
            alloc::dealloc(ptr, layout);
        }
    }
    pub unsafe fn bool_lift(val: u8) -> bool {
        if cfg!(debug_assertions) {
            match val {
                0 => false,
                1 => true,
                _ => panic!("invalid bool discriminant"),
            }
        } else {
            val != 0
        }
    }
    pub unsafe fn string_lift(bytes: Vec<u8>) -> String {
        if cfg!(debug_assertions) {
            String::from_utf8(bytes).unwrap()
        } else {
            unsafe { String::from_utf8_unchecked(bytes) }
        }
    }
    pub fn as_i32<T: AsI32>(t: T) -> i32 {
        t.as_i32()
    }
    pub trait AsI32 {
        fn as_i32(self) -> i32;
    }
    impl<'a, T: Copy + AsI32> AsI32 for &'a T {
        fn as_i32(self) -> i32 {
            (*self).as_i32()
        }
    }
    impl AsI32 for i32 {
        #[inline]
        fn as_i32(self) -> i32 {
            self as i32
        }
    }
    impl AsI32 for u32 {
        #[inline]
        fn as_i32(self) -> i32 {
            self as i32
        }
    }
    impl AsI32 for i16 {
        #[inline]
        fn as_i32(self) -> i32 {
            self as i32
        }
    }
    impl AsI32 for u16 {
        #[inline]
        fn as_i32(self) -> i32 {
            self as i32
        }
    }
    impl AsI32 for i8 {
        #[inline]
        fn as_i32(self) -> i32 {
            self as i32
        }
    }
    impl AsI32 for u8 {
        #[inline]
        fn as_i32(self) -> i32 {
            self as i32
        }
    }
    impl AsI32 for char {
        #[inline]
        fn as_i32(self) -> i32 {
            self as i32
        }
    }
    impl AsI32 for usize {
        #[inline]
        fn as_i32(self) -> i32 {
            self as i32
        }
    }
    pub fn as_i64<T: AsI64>(t: T) -> i64 {
        t.as_i64()
    }
    pub trait AsI64 {
        fn as_i64(self) -> i64;
    }
    impl<'a, T: Copy + AsI64> AsI64 for &'a T {
        fn as_i64(self) -> i64 {
            (*self).as_i64()
        }
    }
    impl AsI64 for i64 {
        #[inline]
        fn as_i64(self) -> i64 {
            self as i64
        }
    }
    impl AsI64 for u64 {
        #[inline]
        fn as_i64(self) -> i64 {
            self as i64
        }
    }
    #[cfg(target_arch = "wasm32")]
    pub fn run_ctors_once() {
        wit_bindgen::rt::run_ctors_once();
    }
    extern crate alloc as alloc_crate;
}
pub mod wit_future {
    #![allow(dead_code, unused_variables, clippy::all)]
    #[doc(hidden)]
    pub trait FuturePayload: Unpin + Sized + 'static {
        const VTABLE: &'static wit_bindgen::rt::async_support::FutureVtable<Self>;
    }
    #[doc(hidden)]
    #[allow(unused_unsafe)]
    pub mod vtable0 {
        #[cfg(not(target_arch = "wasm32"))]
        unsafe extern "C" fn cancel_write(_: u32) -> u32 {
            unreachable!()
        }
        #[cfg(not(target_arch = "wasm32"))]
        unsafe extern "C" fn cancel_read(_: u32) -> u32 {
            unreachable!()
        }
        #[cfg(not(target_arch = "wasm32"))]
        unsafe extern "C" fn drop_writable(_: u32) {
            unreachable!()
        }
        #[cfg(not(target_arch = "wasm32"))]
        unsafe extern "C" fn drop_readable(_: u32) {
            unreachable!()
        }
        #[cfg(not(target_arch = "wasm32"))]
        unsafe extern "C" fn new() -> u64 {
            unreachable!()
        }
        #[cfg(not(target_arch = "wasm32"))]
        unsafe extern "C" fn start_read(_: u32, _: *mut u8) -> u32 {
            unreachable!()
        }
        #[cfg(not(target_arch = "wasm32"))]
        unsafe extern "C" fn start_write(_: u32, _: *const u8) -> u32 {
            unreachable!()
        }
        #[cfg(target_arch = "wasm32")]
        #[link(wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06")]
        unsafe extern "C" {
            #[link_name = "[future-new-1][static]request.new"]
            fn new() -> u64;
            #[link_name = "[future-cancel-write-1][static]request.new"]
            fn cancel_write(_: u32) -> u32;
            #[link_name = "[future-cancel-read-1][static]request.new"]
            fn cancel_read(_: u32) -> u32;
            #[link_name = "[future-drop-writable-1][static]request.new"]
            fn drop_writable(_: u32);
            #[link_name = "[future-drop-readable-1][static]request.new"]
            fn drop_readable(_: u32);
            #[link_name = "[async-lower][future-read-1][static]request.new"]
            fn start_read(_: u32, _: *mut u8) -> u32;
            #[link_name = "[async-lower][future-write-1][static]request.new"]
            fn start_write(_: u32, _: *const u8) -> u32;
        }
        unsafe fn lift(
            ptr: *mut u8,
        ) -> Result<
            Option<super::super::wasi::http::types::Trailers>,
            super::super::wasi::http::types::ErrorCode,
        > {
            unsafe {
                let l0 = i32::from(*ptr.add(0).cast::<u8>());
                match l0 {
                    0 => {
                        let e = {
                            let l1 = i32::from(*ptr.add(8).cast::<u8>());
                            match l1 {
                                0 => None,
                                1 => {
                                    let e = {
                                        let l2 = *ptr.add(12).cast::<i32>();
                                        super::super::wasi::http::types::Fields::from_handle(
                                            l2 as u32,
                                        )
                                    };
                                    Some(e)
                                }
                                _ => super::super::_rt::invalid_enum_discriminant(),
                            }
                        };
                        Ok(e)
                    }
                    1 => {
                        let e = {
                            let l3 = i32::from(*ptr.add(8).cast::<u8>());
                            use super::super::wasi::http::types::ErrorCode as V65;
                            let v65 = match l3 {
                                0 => V65::DnsTimeout,
                                1 => {
                                    let e65 = {
                                        let l4 = i32::from(*ptr.add(16).cast::<u8>());
                                        let l8 = i32::from(
                                            *ptr
                                                .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                .cast::<u8>(),
                                        );
                                        super::super::wasi::http::types::DnsErrorPayload {
                                            rcode: match l4 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l5 = *ptr
                                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<*mut u8>();
                                                        let l6 = *ptr
                                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<usize>();
                                                        let len7 = l6;
                                                        let bytes7 = super::super::_rt::Vec::from_raw_parts(
                                                            l5.cast(),
                                                            len7,
                                                            len7,
                                                        );
                                                        super::super::_rt::string_lift(bytes7)
                                                    };
                                                    Some(e)
                                                }
                                                _ => super::super::_rt::invalid_enum_discriminant(),
                                            },
                                            info_code: match l8 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l9 = i32::from(
                                                            *ptr
                                                                .add(18 + 3 * ::core::mem::size_of::<*const u8>())
                                                                .cast::<u16>(),
                                                        );
                                                        l9 as u16
                                                    };
                                                    Some(e)
                                                }
                                                _ => super::super::_rt::invalid_enum_discriminant(),
                                            },
                                        }
                                    };
                                    V65::DnsError(e65)
                                }
                                2 => V65::DestinationNotFound,
                                3 => V65::DestinationUnavailable,
                                4 => V65::DestinationIpProhibited,
                                5 => V65::DestinationIpUnroutable,
                                6 => V65::ConnectionRefused,
                                7 => V65::ConnectionTerminated,
                                8 => V65::ConnectionTimeout,
                                9 => V65::ConnectionReadTimeout,
                                10 => V65::ConnectionWriteTimeout,
                                11 => V65::ConnectionLimitReached,
                                12 => V65::TlsProtocolError,
                                13 => V65::TlsCertificateError,
                                14 => {
                                    let e65 = {
                                        let l10 = i32::from(*ptr.add(16).cast::<u8>());
                                        let l12 = i32::from(
                                            *ptr
                                                .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                .cast::<u8>(),
                                        );
                                        super::super::wasi::http::types::TlsAlertReceivedPayload {
                                            alert_id: match l10 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l11 = i32::from(*ptr.add(17).cast::<u8>());
                                                        l11 as u8
                                                    };
                                                    Some(e)
                                                }
                                                _ => super::super::_rt::invalid_enum_discriminant(),
                                            },
                                            alert_message: match l12 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l13 = *ptr
                                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<*mut u8>();
                                                        let l14 = *ptr
                                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<usize>();
                                                        let len15 = l14;
                                                        let bytes15 = super::super::_rt::Vec::from_raw_parts(
                                                            l13.cast(),
                                                            len15,
                                                            len15,
                                                        );
                                                        super::super::_rt::string_lift(bytes15)
                                                    };
                                                    Some(e)
                                                }
                                                _ => super::super::_rt::invalid_enum_discriminant(),
                                            },
                                        }
                                    };
                                    V65::TlsAlertReceived(e65)
                                }
                                15 => V65::HttpRequestDenied,
                                16 => V65::HttpRequestLengthRequired,
                                17 => {
                                    let e65 = {
                                        let l16 = i32::from(*ptr.add(16).cast::<u8>());
                                        match l16 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l17 = *ptr.add(24).cast::<i64>();
                                                    l17 as u64
                                                };
                                                Some(e)
                                            }
                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    V65::HttpRequestBodySize(e65)
                                }
                                18 => V65::HttpRequestMethodInvalid,
                                19 => V65::HttpRequestUriInvalid,
                                20 => V65::HttpRequestUriTooLong,
                                21 => {
                                    let e65 = {
                                        let l18 = i32::from(*ptr.add(16).cast::<u8>());
                                        match l18 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l19 = *ptr.add(20).cast::<i32>();
                                                    l19 as u32
                                                };
                                                Some(e)
                                            }
                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    V65::HttpRequestHeaderSectionSize(e65)
                                }
                                22 => {
                                    let e65 = {
                                        let l20 = i32::from(*ptr.add(16).cast::<u8>());
                                        match l20 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l21 = i32::from(
                                                        *ptr
                                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<u8>(),
                                                    );
                                                    let l25 = i32::from(
                                                        *ptr
                                                            .add(16 + 4 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<u8>(),
                                                    );
                                                    super::super::wasi::http::types::FieldSizePayload {
                                                        field_name: match l21 {
                                                            0 => None,
                                                            1 => {
                                                                let e = {
                                                                    let l22 = *ptr
                                                                        .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                                        .cast::<*mut u8>();
                                                                    let l23 = *ptr
                                                                        .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                                        .cast::<usize>();
                                                                    let len24 = l23;
                                                                    let bytes24 = super::super::_rt::Vec::from_raw_parts(
                                                                        l22.cast(),
                                                                        len24,
                                                                        len24,
                                                                    );
                                                                    super::super::_rt::string_lift(bytes24)
                                                                };
                                                                Some(e)
                                                            }
                                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                                        },
                                                        field_size: match l25 {
                                                            0 => None,
                                                            1 => {
                                                                let e = {
                                                                    let l26 = *ptr
                                                                        .add(20 + 4 * ::core::mem::size_of::<*const u8>())
                                                                        .cast::<i32>();
                                                                    l26 as u32
                                                                };
                                                                Some(e)
                                                            }
                                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                                        },
                                                    }
                                                };
                                                Some(e)
                                            }
                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    V65::HttpRequestHeaderSize(e65)
                                }
                                23 => {
                                    let e65 = {
                                        let l27 = i32::from(*ptr.add(16).cast::<u8>());
                                        match l27 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l28 = *ptr.add(20).cast::<i32>();
                                                    l28 as u32
                                                };
                                                Some(e)
                                            }
                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    V65::HttpRequestTrailerSectionSize(e65)
                                }
                                24 => {
                                    let e65 = {
                                        let l29 = i32::from(*ptr.add(16).cast::<u8>());
                                        let l33 = i32::from(
                                            *ptr
                                                .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                .cast::<u8>(),
                                        );
                                        super::super::wasi::http::types::FieldSizePayload {
                                            field_name: match l29 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l30 = *ptr
                                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<*mut u8>();
                                                        let l31 = *ptr
                                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<usize>();
                                                        let len32 = l31;
                                                        let bytes32 = super::super::_rt::Vec::from_raw_parts(
                                                            l30.cast(),
                                                            len32,
                                                            len32,
                                                        );
                                                        super::super::_rt::string_lift(bytes32)
                                                    };
                                                    Some(e)
                                                }
                                                _ => super::super::_rt::invalid_enum_discriminant(),
                                            },
                                            field_size: match l33 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l34 = *ptr
                                                            .add(20 + 3 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<i32>();
                                                        l34 as u32
                                                    };
                                                    Some(e)
                                                }
                                                _ => super::super::_rt::invalid_enum_discriminant(),
                                            },
                                        }
                                    };
                                    V65::HttpRequestTrailerSize(e65)
                                }
                                25 => V65::HttpResponseIncomplete,
                                26 => {
                                    let e65 = {
                                        let l35 = i32::from(*ptr.add(16).cast::<u8>());
                                        match l35 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l36 = *ptr.add(20).cast::<i32>();
                                                    l36 as u32
                                                };
                                                Some(e)
                                            }
                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    V65::HttpResponseHeaderSectionSize(e65)
                                }
                                27 => {
                                    let e65 = {
                                        let l37 = i32::from(*ptr.add(16).cast::<u8>());
                                        let l41 = i32::from(
                                            *ptr
                                                .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                .cast::<u8>(),
                                        );
                                        super::super::wasi::http::types::FieldSizePayload {
                                            field_name: match l37 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l38 = *ptr
                                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<*mut u8>();
                                                        let l39 = *ptr
                                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<usize>();
                                                        let len40 = l39;
                                                        let bytes40 = super::super::_rt::Vec::from_raw_parts(
                                                            l38.cast(),
                                                            len40,
                                                            len40,
                                                        );
                                                        super::super::_rt::string_lift(bytes40)
                                                    };
                                                    Some(e)
                                                }
                                                _ => super::super::_rt::invalid_enum_discriminant(),
                                            },
                                            field_size: match l41 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l42 = *ptr
                                                            .add(20 + 3 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<i32>();
                                                        l42 as u32
                                                    };
                                                    Some(e)
                                                }
                                                _ => super::super::_rt::invalid_enum_discriminant(),
                                            },
                                        }
                                    };
                                    V65::HttpResponseHeaderSize(e65)
                                }
                                28 => {
                                    let e65 = {
                                        let l43 = i32::from(*ptr.add(16).cast::<u8>());
                                        match l43 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l44 = *ptr.add(24).cast::<i64>();
                                                    l44 as u64
                                                };
                                                Some(e)
                                            }
                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    V65::HttpResponseBodySize(e65)
                                }
                                29 => {
                                    let e65 = {
                                        let l45 = i32::from(*ptr.add(16).cast::<u8>());
                                        match l45 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l46 = *ptr.add(20).cast::<i32>();
                                                    l46 as u32
                                                };
                                                Some(e)
                                            }
                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    V65::HttpResponseTrailerSectionSize(e65)
                                }
                                30 => {
                                    let e65 = {
                                        let l47 = i32::from(*ptr.add(16).cast::<u8>());
                                        let l51 = i32::from(
                                            *ptr
                                                .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                .cast::<u8>(),
                                        );
                                        super::super::wasi::http::types::FieldSizePayload {
                                            field_name: match l47 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l48 = *ptr
                                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<*mut u8>();
                                                        let l49 = *ptr
                                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<usize>();
                                                        let len50 = l49;
                                                        let bytes50 = super::super::_rt::Vec::from_raw_parts(
                                                            l48.cast(),
                                                            len50,
                                                            len50,
                                                        );
                                                        super::super::_rt::string_lift(bytes50)
                                                    };
                                                    Some(e)
                                                }
                                                _ => super::super::_rt::invalid_enum_discriminant(),
                                            },
                                            field_size: match l51 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l52 = *ptr
                                                            .add(20 + 3 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<i32>();
                                                        l52 as u32
                                                    };
                                                    Some(e)
                                                }
                                                _ => super::super::_rt::invalid_enum_discriminant(),
                                            },
                                        }
                                    };
                                    V65::HttpResponseTrailerSize(e65)
                                }
                                31 => {
                                    let e65 = {
                                        let l53 = i32::from(*ptr.add(16).cast::<u8>());
                                        match l53 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l54 = *ptr
                                                        .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                        .cast::<*mut u8>();
                                                    let l55 = *ptr
                                                        .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                        .cast::<usize>();
                                                    let len56 = l55;
                                                    let bytes56 = super::super::_rt::Vec::from_raw_parts(
                                                        l54.cast(),
                                                        len56,
                                                        len56,
                                                    );
                                                    super::super::_rt::string_lift(bytes56)
                                                };
                                                Some(e)
                                            }
                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    V65::HttpResponseTransferCoding(e65)
                                }
                                32 => {
                                    let e65 = {
                                        let l57 = i32::from(*ptr.add(16).cast::<u8>());
                                        match l57 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l58 = *ptr
                                                        .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                        .cast::<*mut u8>();
                                                    let l59 = *ptr
                                                        .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                        .cast::<usize>();
                                                    let len60 = l59;
                                                    let bytes60 = super::super::_rt::Vec::from_raw_parts(
                                                        l58.cast(),
                                                        len60,
                                                        len60,
                                                    );
                                                    super::super::_rt::string_lift(bytes60)
                                                };
                                                Some(e)
                                            }
                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    V65::HttpResponseContentCoding(e65)
                                }
                                33 => V65::HttpResponseTimeout,
                                34 => V65::HttpUpgradeFailed,
                                35 => V65::HttpProtocolError,
                                36 => V65::LoopDetected,
                                37 => V65::ConfigurationError,
                                n => {
                                    debug_assert_eq!(n, 38, "invalid enum discriminant");
                                    let e65 = {
                                        let l61 = i32::from(*ptr.add(16).cast::<u8>());
                                        match l61 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l62 = *ptr
                                                        .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                        .cast::<*mut u8>();
                                                    let l63 = *ptr
                                                        .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                        .cast::<usize>();
                                                    let len64 = l63;
                                                    let bytes64 = super::super::_rt::Vec::from_raw_parts(
                                                        l62.cast(),
                                                        len64,
                                                        len64,
                                                    );
                                                    super::super::_rt::string_lift(bytes64)
                                                };
                                                Some(e)
                                            }
                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    V65::InternalError(e65)
                                }
                            };
                            v65
                        };
                        Err(e)
                    }
                    _ => super::super::_rt::invalid_enum_discriminant(),
                }
            }
        }
        unsafe fn lower(
            value: Result<
                Option<super::super::wasi::http::types::Trailers>,
                super::super::wasi::http::types::ErrorCode,
            >,
            ptr: *mut u8,
        ) {
            unsafe {
                match value {
                    Ok(e) => {
                        *ptr.add(0).cast::<u8>() = (0i32) as u8;
                        match e {
                            Some(e) => {
                                *ptr.add(8).cast::<u8>() = (1i32) as u8;
                                *ptr.add(12).cast::<i32>() = (e).take_handle() as i32;
                            }
                            None => {
                                *ptr.add(8).cast::<u8>() = (0i32) as u8;
                            }
                        };
                    }
                    Err(e) => {
                        *ptr.add(0).cast::<u8>() = (1i32) as u8;
                        use super::super::wasi::http::types::ErrorCode as V15;
                        match e {
                            V15::DnsTimeout => {
                                *ptr.add(8).cast::<u8>() = (0i32) as u8;
                            }
                            V15::DnsError(e) => {
                                *ptr.add(8).cast::<u8>() = (1i32) as u8;
                                let super::super::wasi::http::types::DnsErrorPayload {
                                    rcode: rcode0,
                                    info_code: info_code0,
                                } = e;
                                match rcode0 {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        let vec1 = (e.into_bytes()).into_boxed_slice();
                                        let ptr1 = vec1.as_ptr().cast::<u8>();
                                        let len1 = vec1.len();
                                        ::core::mem::forget(vec1);
                                        *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>() = len1;
                                        *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>() = ptr1.cast_mut();
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                                match info_code0 {
                                    Some(e) => {
                                        *ptr
                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u8>() = (1i32) as u8;
                                        *ptr
                                            .add(18 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u16>() = (super::super::_rt::as_i32(e)) as u16;
                                    }
                                    None => {
                                        *ptr
                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::DestinationNotFound => {
                                *ptr.add(8).cast::<u8>() = (2i32) as u8;
                            }
                            V15::DestinationUnavailable => {
                                *ptr.add(8).cast::<u8>() = (3i32) as u8;
                            }
                            V15::DestinationIpProhibited => {
                                *ptr.add(8).cast::<u8>() = (4i32) as u8;
                            }
                            V15::DestinationIpUnroutable => {
                                *ptr.add(8).cast::<u8>() = (5i32) as u8;
                            }
                            V15::ConnectionRefused => {
                                *ptr.add(8).cast::<u8>() = (6i32) as u8;
                            }
                            V15::ConnectionTerminated => {
                                *ptr.add(8).cast::<u8>() = (7i32) as u8;
                            }
                            V15::ConnectionTimeout => {
                                *ptr.add(8).cast::<u8>() = (8i32) as u8;
                            }
                            V15::ConnectionReadTimeout => {
                                *ptr.add(8).cast::<u8>() = (9i32) as u8;
                            }
                            V15::ConnectionWriteTimeout => {
                                *ptr.add(8).cast::<u8>() = (10i32) as u8;
                            }
                            V15::ConnectionLimitReached => {
                                *ptr.add(8).cast::<u8>() = (11i32) as u8;
                            }
                            V15::TlsProtocolError => {
                                *ptr.add(8).cast::<u8>() = (12i32) as u8;
                            }
                            V15::TlsCertificateError => {
                                *ptr.add(8).cast::<u8>() = (13i32) as u8;
                            }
                            V15::TlsAlertReceived(e) => {
                                *ptr.add(8).cast::<u8>() = (14i32) as u8;
                                let super::super::wasi::http::types::TlsAlertReceivedPayload {
                                    alert_id: alert_id2,
                                    alert_message: alert_message2,
                                } = e;
                                match alert_id2 {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        *ptr.add(17).cast::<u8>() = (super::super::_rt::as_i32(e))
                                            as u8;
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                                match alert_message2 {
                                    Some(e) => {
                                        *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u8>() = (1i32) as u8;
                                        let vec3 = (e.into_bytes()).into_boxed_slice();
                                        let ptr3 = vec3.as_ptr().cast::<u8>();
                                        let len3 = vec3.len();
                                        ::core::mem::forget(vec3);
                                        *ptr
                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>() = len3;
                                        *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>() = ptr3.cast_mut();
                                    }
                                    None => {
                                        *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpRequestDenied => {
                                *ptr.add(8).cast::<u8>() = (15i32) as u8;
                            }
                            V15::HttpRequestLengthRequired => {
                                *ptr.add(8).cast::<u8>() = (16i32) as u8;
                            }
                            V15::HttpRequestBodySize(e) => {
                                *ptr.add(8).cast::<u8>() = (17i32) as u8;
                                match e {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        *ptr.add(24).cast::<i64>() = super::super::_rt::as_i64(e);
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpRequestMethodInvalid => {
                                *ptr.add(8).cast::<u8>() = (18i32) as u8;
                            }
                            V15::HttpRequestUriInvalid => {
                                *ptr.add(8).cast::<u8>() = (19i32) as u8;
                            }
                            V15::HttpRequestUriTooLong => {
                                *ptr.add(8).cast::<u8>() = (20i32) as u8;
                            }
                            V15::HttpRequestHeaderSectionSize(e) => {
                                *ptr.add(8).cast::<u8>() = (21i32) as u8;
                                match e {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        *ptr.add(20).cast::<i32>() = super::super::_rt::as_i32(e);
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpRequestHeaderSize(e) => {
                                *ptr.add(8).cast::<u8>() = (22i32) as u8;
                                match e {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        let super::super::wasi::http::types::FieldSizePayload {
                                            field_name: field_name4,
                                            field_size: field_size4,
                                        } = e;
                                        match field_name4 {
                                            Some(e) => {
                                                *ptr
                                                    .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                    .cast::<u8>() = (1i32) as u8;
                                                let vec5 = (e.into_bytes()).into_boxed_slice();
                                                let ptr5 = vec5.as_ptr().cast::<u8>();
                                                let len5 = vec5.len();
                                                ::core::mem::forget(vec5);
                                                *ptr
                                                    .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                    .cast::<usize>() = len5;
                                                *ptr
                                                    .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                    .cast::<*mut u8>() = ptr5.cast_mut();
                                            }
                                            None => {
                                                *ptr
                                                    .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                    .cast::<u8>() = (0i32) as u8;
                                            }
                                        };
                                        match field_size4 {
                                            Some(e) => {
                                                *ptr
                                                    .add(16 + 4 * ::core::mem::size_of::<*const u8>())
                                                    .cast::<u8>() = (1i32) as u8;
                                                *ptr
                                                    .add(20 + 4 * ::core::mem::size_of::<*const u8>())
                                                    .cast::<i32>() = super::super::_rt::as_i32(e);
                                            }
                                            None => {
                                                *ptr
                                                    .add(16 + 4 * ::core::mem::size_of::<*const u8>())
                                                    .cast::<u8>() = (0i32) as u8;
                                            }
                                        };
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpRequestTrailerSectionSize(e) => {
                                *ptr.add(8).cast::<u8>() = (23i32) as u8;
                                match e {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        *ptr.add(20).cast::<i32>() = super::super::_rt::as_i32(e);
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpRequestTrailerSize(e) => {
                                *ptr.add(8).cast::<u8>() = (24i32) as u8;
                                let super::super::wasi::http::types::FieldSizePayload {
                                    field_name: field_name6,
                                    field_size: field_size6,
                                } = e;
                                match field_name6 {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        let vec7 = (e.into_bytes()).into_boxed_slice();
                                        let ptr7 = vec7.as_ptr().cast::<u8>();
                                        let len7 = vec7.len();
                                        ::core::mem::forget(vec7);
                                        *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>() = len7;
                                        *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>() = ptr7.cast_mut();
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                                match field_size6 {
                                    Some(e) => {
                                        *ptr
                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u8>() = (1i32) as u8;
                                        *ptr
                                            .add(20 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<i32>() = super::super::_rt::as_i32(e);
                                    }
                                    None => {
                                        *ptr
                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpResponseIncomplete => {
                                *ptr.add(8).cast::<u8>() = (25i32) as u8;
                            }
                            V15::HttpResponseHeaderSectionSize(e) => {
                                *ptr.add(8).cast::<u8>() = (26i32) as u8;
                                match e {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        *ptr.add(20).cast::<i32>() = super::super::_rt::as_i32(e);
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpResponseHeaderSize(e) => {
                                *ptr.add(8).cast::<u8>() = (27i32) as u8;
                                let super::super::wasi::http::types::FieldSizePayload {
                                    field_name: field_name8,
                                    field_size: field_size8,
                                } = e;
                                match field_name8 {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        let vec9 = (e.into_bytes()).into_boxed_slice();
                                        let ptr9 = vec9.as_ptr().cast::<u8>();
                                        let len9 = vec9.len();
                                        ::core::mem::forget(vec9);
                                        *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>() = len9;
                                        *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>() = ptr9.cast_mut();
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                                match field_size8 {
                                    Some(e) => {
                                        *ptr
                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u8>() = (1i32) as u8;
                                        *ptr
                                            .add(20 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<i32>() = super::super::_rt::as_i32(e);
                                    }
                                    None => {
                                        *ptr
                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpResponseBodySize(e) => {
                                *ptr.add(8).cast::<u8>() = (28i32) as u8;
                                match e {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        *ptr.add(24).cast::<i64>() = super::super::_rt::as_i64(e);
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpResponseTrailerSectionSize(e) => {
                                *ptr.add(8).cast::<u8>() = (29i32) as u8;
                                match e {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        *ptr.add(20).cast::<i32>() = super::super::_rt::as_i32(e);
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpResponseTrailerSize(e) => {
                                *ptr.add(8).cast::<u8>() = (30i32) as u8;
                                let super::super::wasi::http::types::FieldSizePayload {
                                    field_name: field_name10,
                                    field_size: field_size10,
                                } = e;
                                match field_name10 {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        let vec11 = (e.into_bytes()).into_boxed_slice();
                                        let ptr11 = vec11.as_ptr().cast::<u8>();
                                        let len11 = vec11.len();
                                        ::core::mem::forget(vec11);
                                        *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>() = len11;
                                        *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>() = ptr11.cast_mut();
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                                match field_size10 {
                                    Some(e) => {
                                        *ptr
                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u8>() = (1i32) as u8;
                                        *ptr
                                            .add(20 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<i32>() = super::super::_rt::as_i32(e);
                                    }
                                    None => {
                                        *ptr
                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpResponseTransferCoding(e) => {
                                *ptr.add(8).cast::<u8>() = (31i32) as u8;
                                match e {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        let vec12 = (e.into_bytes()).into_boxed_slice();
                                        let ptr12 = vec12.as_ptr().cast::<u8>();
                                        let len12 = vec12.len();
                                        ::core::mem::forget(vec12);
                                        *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>() = len12;
                                        *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>() = ptr12.cast_mut();
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpResponseContentCoding(e) => {
                                *ptr.add(8).cast::<u8>() = (32i32) as u8;
                                match e {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        let vec13 = (e.into_bytes()).into_boxed_slice();
                                        let ptr13 = vec13.as_ptr().cast::<u8>();
                                        let len13 = vec13.len();
                                        ::core::mem::forget(vec13);
                                        *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>() = len13;
                                        *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>() = ptr13.cast_mut();
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpResponseTimeout => {
                                *ptr.add(8).cast::<u8>() = (33i32) as u8;
                            }
                            V15::HttpUpgradeFailed => {
                                *ptr.add(8).cast::<u8>() = (34i32) as u8;
                            }
                            V15::HttpProtocolError => {
                                *ptr.add(8).cast::<u8>() = (35i32) as u8;
                            }
                            V15::LoopDetected => {
                                *ptr.add(8).cast::<u8>() = (36i32) as u8;
                            }
                            V15::ConfigurationError => {
                                *ptr.add(8).cast::<u8>() = (37i32) as u8;
                            }
                            V15::InternalError(e) => {
                                *ptr.add(8).cast::<u8>() = (38i32) as u8;
                                match e {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        let vec14 = (e.into_bytes()).into_boxed_slice();
                                        let ptr14 = vec14.as_ptr().cast::<u8>();
                                        let len14 = vec14.len();
                                        ::core::mem::forget(vec14);
                                        *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>() = len14;
                                        *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>() = ptr14.cast_mut();
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                        }
                    }
                };
            }
        }
        unsafe fn dealloc_lists(ptr: *mut u8) {
            unsafe {
                let l0 = i32::from(*ptr.add(0).cast::<u8>());
                match l0 {
                    0 => {}
                    _ => {
                        let l1 = i32::from(*ptr.add(8).cast::<u8>());
                        match l1 {
                            0 => {}
                            1 => {
                                let l2 = i32::from(*ptr.add(16).cast::<u8>());
                                match l2 {
                                    0 => {}
                                    _ => {
                                        let l3 = *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>();
                                        let l4 = *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>();
                                        super::super::_rt::cabi_dealloc(l3, l4, 1);
                                    }
                                }
                            }
                            2 => {}
                            3 => {}
                            4 => {}
                            5 => {}
                            6 => {}
                            7 => {}
                            8 => {}
                            9 => {}
                            10 => {}
                            11 => {}
                            12 => {}
                            13 => {}
                            14 => {
                                let l5 = i32::from(
                                    *ptr
                                        .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                        .cast::<u8>(),
                                );
                                match l5 {
                                    0 => {}
                                    _ => {
                                        let l6 = *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>();
                                        let l7 = *ptr
                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>();
                                        super::super::_rt::cabi_dealloc(l6, l7, 1);
                                    }
                                }
                            }
                            15 => {}
                            16 => {}
                            17 => {}
                            18 => {}
                            19 => {}
                            20 => {}
                            21 => {}
                            22 => {
                                let l8 = i32::from(*ptr.add(16).cast::<u8>());
                                match l8 {
                                    0 => {}
                                    _ => {
                                        let l9 = i32::from(
                                            *ptr
                                                .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                .cast::<u8>(),
                                        );
                                        match l9 {
                                            0 => {}
                                            _ => {
                                                let l10 = *ptr
                                                    .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                    .cast::<*mut u8>();
                                                let l11 = *ptr
                                                    .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                    .cast::<usize>();
                                                super::super::_rt::cabi_dealloc(l10, l11, 1);
                                            }
                                        }
                                    }
                                }
                            }
                            23 => {}
                            24 => {
                                let l12 = i32::from(*ptr.add(16).cast::<u8>());
                                match l12 {
                                    0 => {}
                                    _ => {
                                        let l13 = *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>();
                                        let l14 = *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>();
                                        super::super::_rt::cabi_dealloc(l13, l14, 1);
                                    }
                                }
                            }
                            25 => {}
                            26 => {}
                            27 => {
                                let l15 = i32::from(*ptr.add(16).cast::<u8>());
                                match l15 {
                                    0 => {}
                                    _ => {
                                        let l16 = *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>();
                                        let l17 = *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>();
                                        super::super::_rt::cabi_dealloc(l16, l17, 1);
                                    }
                                }
                            }
                            28 => {}
                            29 => {}
                            30 => {
                                let l18 = i32::from(*ptr.add(16).cast::<u8>());
                                match l18 {
                                    0 => {}
                                    _ => {
                                        let l19 = *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>();
                                        let l20 = *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>();
                                        super::super::_rt::cabi_dealloc(l19, l20, 1);
                                    }
                                }
                            }
                            31 => {
                                let l21 = i32::from(*ptr.add(16).cast::<u8>());
                                match l21 {
                                    0 => {}
                                    _ => {
                                        let l22 = *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>();
                                        let l23 = *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>();
                                        super::super::_rt::cabi_dealloc(l22, l23, 1);
                                    }
                                }
                            }
                            32 => {
                                let l24 = i32::from(*ptr.add(16).cast::<u8>());
                                match l24 {
                                    0 => {}
                                    _ => {
                                        let l25 = *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>();
                                        let l26 = *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>();
                                        super::super::_rt::cabi_dealloc(l25, l26, 1);
                                    }
                                }
                            }
                            33 => {}
                            34 => {}
                            35 => {}
                            36 => {}
                            37 => {}
                            _ => {
                                let l27 = i32::from(*ptr.add(16).cast::<u8>());
                                match l27 {
                                    0 => {}
                                    _ => {
                                        let l28 = *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>();
                                        let l29 = *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>();
                                        super::super::_rt::cabi_dealloc(l28, l29, 1);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        pub static VTABLE: wit_bindgen::rt::async_support::FutureVtable<
            Result<
                Option<super::super::wasi::http::types::Trailers>,
                super::super::wasi::http::types::ErrorCode,
            >,
        > = wit_bindgen::rt::async_support::FutureVtable::<
            Result<
                Option<super::super::wasi::http::types::Trailers>,
                super::super::wasi::http::types::ErrorCode,
            >,
        > {
            cancel_write,
            cancel_read,
            drop_writable,
            drop_readable,
            dealloc_lists,
            layout: unsafe { ::std::alloc::Layout::from_size_align_unchecked(40, 8) },
            lift,
            lower,
            new,
            start_read,
            start_write,
        };
        impl super::FuturePayload
        for Result<
            Option<super::super::wasi::http::types::Trailers>,
            super::super::wasi::http::types::ErrorCode,
        > {
            const VTABLE: &'static wit_bindgen::rt::async_support::FutureVtable<Self> = &VTABLE;
        }
    }
    #[doc(hidden)]
    #[allow(unused_unsafe)]
    pub mod vtable1 {
        #[cfg(not(target_arch = "wasm32"))]
        unsafe extern "C" fn cancel_write(_: u32) -> u32 {
            unreachable!()
        }
        #[cfg(not(target_arch = "wasm32"))]
        unsafe extern "C" fn cancel_read(_: u32) -> u32 {
            unreachable!()
        }
        #[cfg(not(target_arch = "wasm32"))]
        unsafe extern "C" fn drop_writable(_: u32) {
            unreachable!()
        }
        #[cfg(not(target_arch = "wasm32"))]
        unsafe extern "C" fn drop_readable(_: u32) {
            unreachable!()
        }
        #[cfg(not(target_arch = "wasm32"))]
        unsafe extern "C" fn new() -> u64 {
            unreachable!()
        }
        #[cfg(not(target_arch = "wasm32"))]
        unsafe extern "C" fn start_read(_: u32, _: *mut u8) -> u32 {
            unreachable!()
        }
        #[cfg(not(target_arch = "wasm32"))]
        unsafe extern "C" fn start_write(_: u32, _: *const u8) -> u32 {
            unreachable!()
        }
        #[cfg(target_arch = "wasm32")]
        #[link(wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06")]
        unsafe extern "C" {
            #[link_name = "[future-new-2][static]request.new"]
            fn new() -> u64;
            #[link_name = "[future-cancel-write-2][static]request.new"]
            fn cancel_write(_: u32) -> u32;
            #[link_name = "[future-cancel-read-2][static]request.new"]
            fn cancel_read(_: u32) -> u32;
            #[link_name = "[future-drop-writable-2][static]request.new"]
            fn drop_writable(_: u32);
            #[link_name = "[future-drop-readable-2][static]request.new"]
            fn drop_readable(_: u32);
            #[link_name = "[async-lower][future-read-2][static]request.new"]
            fn start_read(_: u32, _: *mut u8) -> u32;
            #[link_name = "[async-lower][future-write-2][static]request.new"]
            fn start_write(_: u32, _: *const u8) -> u32;
        }
        unsafe fn lift(
            ptr: *mut u8,
        ) -> Result<(), super::super::wasi::http::types::ErrorCode> {
            unsafe {
                let l0 = i32::from(*ptr.add(0).cast::<u8>());
                match l0 {
                    0 => {
                        let e = ();
                        Ok(e)
                    }
                    1 => {
                        let e = {
                            let l1 = i32::from(*ptr.add(8).cast::<u8>());
                            use super::super::wasi::http::types::ErrorCode as V63;
                            let v63 = match l1 {
                                0 => V63::DnsTimeout,
                                1 => {
                                    let e63 = {
                                        let l2 = i32::from(*ptr.add(16).cast::<u8>());
                                        let l6 = i32::from(
                                            *ptr
                                                .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                .cast::<u8>(),
                                        );
                                        super::super::wasi::http::types::DnsErrorPayload {
                                            rcode: match l2 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l3 = *ptr
                                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<*mut u8>();
                                                        let l4 = *ptr
                                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<usize>();
                                                        let len5 = l4;
                                                        let bytes5 = super::super::_rt::Vec::from_raw_parts(
                                                            l3.cast(),
                                                            len5,
                                                            len5,
                                                        );
                                                        super::super::_rt::string_lift(bytes5)
                                                    };
                                                    Some(e)
                                                }
                                                _ => super::super::_rt::invalid_enum_discriminant(),
                                            },
                                            info_code: match l6 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l7 = i32::from(
                                                            *ptr
                                                                .add(18 + 3 * ::core::mem::size_of::<*const u8>())
                                                                .cast::<u16>(),
                                                        );
                                                        l7 as u16
                                                    };
                                                    Some(e)
                                                }
                                                _ => super::super::_rt::invalid_enum_discriminant(),
                                            },
                                        }
                                    };
                                    V63::DnsError(e63)
                                }
                                2 => V63::DestinationNotFound,
                                3 => V63::DestinationUnavailable,
                                4 => V63::DestinationIpProhibited,
                                5 => V63::DestinationIpUnroutable,
                                6 => V63::ConnectionRefused,
                                7 => V63::ConnectionTerminated,
                                8 => V63::ConnectionTimeout,
                                9 => V63::ConnectionReadTimeout,
                                10 => V63::ConnectionWriteTimeout,
                                11 => V63::ConnectionLimitReached,
                                12 => V63::TlsProtocolError,
                                13 => V63::TlsCertificateError,
                                14 => {
                                    let e63 = {
                                        let l8 = i32::from(*ptr.add(16).cast::<u8>());
                                        let l10 = i32::from(
                                            *ptr
                                                .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                .cast::<u8>(),
                                        );
                                        super::super::wasi::http::types::TlsAlertReceivedPayload {
                                            alert_id: match l8 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l9 = i32::from(*ptr.add(17).cast::<u8>());
                                                        l9 as u8
                                                    };
                                                    Some(e)
                                                }
                                                _ => super::super::_rt::invalid_enum_discriminant(),
                                            },
                                            alert_message: match l10 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l11 = *ptr
                                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<*mut u8>();
                                                        let l12 = *ptr
                                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<usize>();
                                                        let len13 = l12;
                                                        let bytes13 = super::super::_rt::Vec::from_raw_parts(
                                                            l11.cast(),
                                                            len13,
                                                            len13,
                                                        );
                                                        super::super::_rt::string_lift(bytes13)
                                                    };
                                                    Some(e)
                                                }
                                                _ => super::super::_rt::invalid_enum_discriminant(),
                                            },
                                        }
                                    };
                                    V63::TlsAlertReceived(e63)
                                }
                                15 => V63::HttpRequestDenied,
                                16 => V63::HttpRequestLengthRequired,
                                17 => {
                                    let e63 = {
                                        let l14 = i32::from(*ptr.add(16).cast::<u8>());
                                        match l14 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l15 = *ptr.add(24).cast::<i64>();
                                                    l15 as u64
                                                };
                                                Some(e)
                                            }
                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    V63::HttpRequestBodySize(e63)
                                }
                                18 => V63::HttpRequestMethodInvalid,
                                19 => V63::HttpRequestUriInvalid,
                                20 => V63::HttpRequestUriTooLong,
                                21 => {
                                    let e63 = {
                                        let l16 = i32::from(*ptr.add(16).cast::<u8>());
                                        match l16 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l17 = *ptr.add(20).cast::<i32>();
                                                    l17 as u32
                                                };
                                                Some(e)
                                            }
                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    V63::HttpRequestHeaderSectionSize(e63)
                                }
                                22 => {
                                    let e63 = {
                                        let l18 = i32::from(*ptr.add(16).cast::<u8>());
                                        match l18 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l19 = i32::from(
                                                        *ptr
                                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<u8>(),
                                                    );
                                                    let l23 = i32::from(
                                                        *ptr
                                                            .add(16 + 4 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<u8>(),
                                                    );
                                                    super::super::wasi::http::types::FieldSizePayload {
                                                        field_name: match l19 {
                                                            0 => None,
                                                            1 => {
                                                                let e = {
                                                                    let l20 = *ptr
                                                                        .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                                        .cast::<*mut u8>();
                                                                    let l21 = *ptr
                                                                        .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                                        .cast::<usize>();
                                                                    let len22 = l21;
                                                                    let bytes22 = super::super::_rt::Vec::from_raw_parts(
                                                                        l20.cast(),
                                                                        len22,
                                                                        len22,
                                                                    );
                                                                    super::super::_rt::string_lift(bytes22)
                                                                };
                                                                Some(e)
                                                            }
                                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                                        },
                                                        field_size: match l23 {
                                                            0 => None,
                                                            1 => {
                                                                let e = {
                                                                    let l24 = *ptr
                                                                        .add(20 + 4 * ::core::mem::size_of::<*const u8>())
                                                                        .cast::<i32>();
                                                                    l24 as u32
                                                                };
                                                                Some(e)
                                                            }
                                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                                        },
                                                    }
                                                };
                                                Some(e)
                                            }
                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    V63::HttpRequestHeaderSize(e63)
                                }
                                23 => {
                                    let e63 = {
                                        let l25 = i32::from(*ptr.add(16).cast::<u8>());
                                        match l25 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l26 = *ptr.add(20).cast::<i32>();
                                                    l26 as u32
                                                };
                                                Some(e)
                                            }
                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    V63::HttpRequestTrailerSectionSize(e63)
                                }
                                24 => {
                                    let e63 = {
                                        let l27 = i32::from(*ptr.add(16).cast::<u8>());
                                        let l31 = i32::from(
                                            *ptr
                                                .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                .cast::<u8>(),
                                        );
                                        super::super::wasi::http::types::FieldSizePayload {
                                            field_name: match l27 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l28 = *ptr
                                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<*mut u8>();
                                                        let l29 = *ptr
                                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<usize>();
                                                        let len30 = l29;
                                                        let bytes30 = super::super::_rt::Vec::from_raw_parts(
                                                            l28.cast(),
                                                            len30,
                                                            len30,
                                                        );
                                                        super::super::_rt::string_lift(bytes30)
                                                    };
                                                    Some(e)
                                                }
                                                _ => super::super::_rt::invalid_enum_discriminant(),
                                            },
                                            field_size: match l31 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l32 = *ptr
                                                            .add(20 + 3 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<i32>();
                                                        l32 as u32
                                                    };
                                                    Some(e)
                                                }
                                                _ => super::super::_rt::invalid_enum_discriminant(),
                                            },
                                        }
                                    };
                                    V63::HttpRequestTrailerSize(e63)
                                }
                                25 => V63::HttpResponseIncomplete,
                                26 => {
                                    let e63 = {
                                        let l33 = i32::from(*ptr.add(16).cast::<u8>());
                                        match l33 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l34 = *ptr.add(20).cast::<i32>();
                                                    l34 as u32
                                                };
                                                Some(e)
                                            }
                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    V63::HttpResponseHeaderSectionSize(e63)
                                }
                                27 => {
                                    let e63 = {
                                        let l35 = i32::from(*ptr.add(16).cast::<u8>());
                                        let l39 = i32::from(
                                            *ptr
                                                .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                .cast::<u8>(),
                                        );
                                        super::super::wasi::http::types::FieldSizePayload {
                                            field_name: match l35 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l36 = *ptr
                                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<*mut u8>();
                                                        let l37 = *ptr
                                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<usize>();
                                                        let len38 = l37;
                                                        let bytes38 = super::super::_rt::Vec::from_raw_parts(
                                                            l36.cast(),
                                                            len38,
                                                            len38,
                                                        );
                                                        super::super::_rt::string_lift(bytes38)
                                                    };
                                                    Some(e)
                                                }
                                                _ => super::super::_rt::invalid_enum_discriminant(),
                                            },
                                            field_size: match l39 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l40 = *ptr
                                                            .add(20 + 3 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<i32>();
                                                        l40 as u32
                                                    };
                                                    Some(e)
                                                }
                                                _ => super::super::_rt::invalid_enum_discriminant(),
                                            },
                                        }
                                    };
                                    V63::HttpResponseHeaderSize(e63)
                                }
                                28 => {
                                    let e63 = {
                                        let l41 = i32::from(*ptr.add(16).cast::<u8>());
                                        match l41 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l42 = *ptr.add(24).cast::<i64>();
                                                    l42 as u64
                                                };
                                                Some(e)
                                            }
                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    V63::HttpResponseBodySize(e63)
                                }
                                29 => {
                                    let e63 = {
                                        let l43 = i32::from(*ptr.add(16).cast::<u8>());
                                        match l43 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l44 = *ptr.add(20).cast::<i32>();
                                                    l44 as u32
                                                };
                                                Some(e)
                                            }
                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    V63::HttpResponseTrailerSectionSize(e63)
                                }
                                30 => {
                                    let e63 = {
                                        let l45 = i32::from(*ptr.add(16).cast::<u8>());
                                        let l49 = i32::from(
                                            *ptr
                                                .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                .cast::<u8>(),
                                        );
                                        super::super::wasi::http::types::FieldSizePayload {
                                            field_name: match l45 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l46 = *ptr
                                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<*mut u8>();
                                                        let l47 = *ptr
                                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<usize>();
                                                        let len48 = l47;
                                                        let bytes48 = super::super::_rt::Vec::from_raw_parts(
                                                            l46.cast(),
                                                            len48,
                                                            len48,
                                                        );
                                                        super::super::_rt::string_lift(bytes48)
                                                    };
                                                    Some(e)
                                                }
                                                _ => super::super::_rt::invalid_enum_discriminant(),
                                            },
                                            field_size: match l49 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l50 = *ptr
                                                            .add(20 + 3 * ::core::mem::size_of::<*const u8>())
                                                            .cast::<i32>();
                                                        l50 as u32
                                                    };
                                                    Some(e)
                                                }
                                                _ => super::super::_rt::invalid_enum_discriminant(),
                                            },
                                        }
                                    };
                                    V63::HttpResponseTrailerSize(e63)
                                }
                                31 => {
                                    let e63 = {
                                        let l51 = i32::from(*ptr.add(16).cast::<u8>());
                                        match l51 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l52 = *ptr
                                                        .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                        .cast::<*mut u8>();
                                                    let l53 = *ptr
                                                        .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                        .cast::<usize>();
                                                    let len54 = l53;
                                                    let bytes54 = super::super::_rt::Vec::from_raw_parts(
                                                        l52.cast(),
                                                        len54,
                                                        len54,
                                                    );
                                                    super::super::_rt::string_lift(bytes54)
                                                };
                                                Some(e)
                                            }
                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    V63::HttpResponseTransferCoding(e63)
                                }
                                32 => {
                                    let e63 = {
                                        let l55 = i32::from(*ptr.add(16).cast::<u8>());
                                        match l55 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l56 = *ptr
                                                        .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                        .cast::<*mut u8>();
                                                    let l57 = *ptr
                                                        .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                        .cast::<usize>();
                                                    let len58 = l57;
                                                    let bytes58 = super::super::_rt::Vec::from_raw_parts(
                                                        l56.cast(),
                                                        len58,
                                                        len58,
                                                    );
                                                    super::super::_rt::string_lift(bytes58)
                                                };
                                                Some(e)
                                            }
                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    V63::HttpResponseContentCoding(e63)
                                }
                                33 => V63::HttpResponseTimeout,
                                34 => V63::HttpUpgradeFailed,
                                35 => V63::HttpProtocolError,
                                36 => V63::LoopDetected,
                                37 => V63::ConfigurationError,
                                n => {
                                    debug_assert_eq!(n, 38, "invalid enum discriminant");
                                    let e63 = {
                                        let l59 = i32::from(*ptr.add(16).cast::<u8>());
                                        match l59 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l60 = *ptr
                                                        .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                        .cast::<*mut u8>();
                                                    let l61 = *ptr
                                                        .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                        .cast::<usize>();
                                                    let len62 = l61;
                                                    let bytes62 = super::super::_rt::Vec::from_raw_parts(
                                                        l60.cast(),
                                                        len62,
                                                        len62,
                                                    );
                                                    super::super::_rt::string_lift(bytes62)
                                                };
                                                Some(e)
                                            }
                                            _ => super::super::_rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    V63::InternalError(e63)
                                }
                            };
                            v63
                        };
                        Err(e)
                    }
                    _ => super::super::_rt::invalid_enum_discriminant(),
                }
            }
        }
        unsafe fn lower(
            value: Result<(), super::super::wasi::http::types::ErrorCode>,
            ptr: *mut u8,
        ) {
            unsafe {
                match value {
                    Ok(_) => {
                        *ptr.add(0).cast::<u8>() = (0i32) as u8;
                    }
                    Err(e) => {
                        *ptr.add(0).cast::<u8>() = (1i32) as u8;
                        use super::super::wasi::http::types::ErrorCode as V15;
                        match e {
                            V15::DnsTimeout => {
                                *ptr.add(8).cast::<u8>() = (0i32) as u8;
                            }
                            V15::DnsError(e) => {
                                *ptr.add(8).cast::<u8>() = (1i32) as u8;
                                let super::super::wasi::http::types::DnsErrorPayload {
                                    rcode: rcode0,
                                    info_code: info_code0,
                                } = e;
                                match rcode0 {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        let vec1 = (e.into_bytes()).into_boxed_slice();
                                        let ptr1 = vec1.as_ptr().cast::<u8>();
                                        let len1 = vec1.len();
                                        ::core::mem::forget(vec1);
                                        *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>() = len1;
                                        *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>() = ptr1.cast_mut();
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                                match info_code0 {
                                    Some(e) => {
                                        *ptr
                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u8>() = (1i32) as u8;
                                        *ptr
                                            .add(18 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u16>() = (super::super::_rt::as_i32(e)) as u16;
                                    }
                                    None => {
                                        *ptr
                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::DestinationNotFound => {
                                *ptr.add(8).cast::<u8>() = (2i32) as u8;
                            }
                            V15::DestinationUnavailable => {
                                *ptr.add(8).cast::<u8>() = (3i32) as u8;
                            }
                            V15::DestinationIpProhibited => {
                                *ptr.add(8).cast::<u8>() = (4i32) as u8;
                            }
                            V15::DestinationIpUnroutable => {
                                *ptr.add(8).cast::<u8>() = (5i32) as u8;
                            }
                            V15::ConnectionRefused => {
                                *ptr.add(8).cast::<u8>() = (6i32) as u8;
                            }
                            V15::ConnectionTerminated => {
                                *ptr.add(8).cast::<u8>() = (7i32) as u8;
                            }
                            V15::ConnectionTimeout => {
                                *ptr.add(8).cast::<u8>() = (8i32) as u8;
                            }
                            V15::ConnectionReadTimeout => {
                                *ptr.add(8).cast::<u8>() = (9i32) as u8;
                            }
                            V15::ConnectionWriteTimeout => {
                                *ptr.add(8).cast::<u8>() = (10i32) as u8;
                            }
                            V15::ConnectionLimitReached => {
                                *ptr.add(8).cast::<u8>() = (11i32) as u8;
                            }
                            V15::TlsProtocolError => {
                                *ptr.add(8).cast::<u8>() = (12i32) as u8;
                            }
                            V15::TlsCertificateError => {
                                *ptr.add(8).cast::<u8>() = (13i32) as u8;
                            }
                            V15::TlsAlertReceived(e) => {
                                *ptr.add(8).cast::<u8>() = (14i32) as u8;
                                let super::super::wasi::http::types::TlsAlertReceivedPayload {
                                    alert_id: alert_id2,
                                    alert_message: alert_message2,
                                } = e;
                                match alert_id2 {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        *ptr.add(17).cast::<u8>() = (super::super::_rt::as_i32(e))
                                            as u8;
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                                match alert_message2 {
                                    Some(e) => {
                                        *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u8>() = (1i32) as u8;
                                        let vec3 = (e.into_bytes()).into_boxed_slice();
                                        let ptr3 = vec3.as_ptr().cast::<u8>();
                                        let len3 = vec3.len();
                                        ::core::mem::forget(vec3);
                                        *ptr
                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>() = len3;
                                        *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>() = ptr3.cast_mut();
                                    }
                                    None => {
                                        *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpRequestDenied => {
                                *ptr.add(8).cast::<u8>() = (15i32) as u8;
                            }
                            V15::HttpRequestLengthRequired => {
                                *ptr.add(8).cast::<u8>() = (16i32) as u8;
                            }
                            V15::HttpRequestBodySize(e) => {
                                *ptr.add(8).cast::<u8>() = (17i32) as u8;
                                match e {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        *ptr.add(24).cast::<i64>() = super::super::_rt::as_i64(e);
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpRequestMethodInvalid => {
                                *ptr.add(8).cast::<u8>() = (18i32) as u8;
                            }
                            V15::HttpRequestUriInvalid => {
                                *ptr.add(8).cast::<u8>() = (19i32) as u8;
                            }
                            V15::HttpRequestUriTooLong => {
                                *ptr.add(8).cast::<u8>() = (20i32) as u8;
                            }
                            V15::HttpRequestHeaderSectionSize(e) => {
                                *ptr.add(8).cast::<u8>() = (21i32) as u8;
                                match e {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        *ptr.add(20).cast::<i32>() = super::super::_rt::as_i32(e);
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpRequestHeaderSize(e) => {
                                *ptr.add(8).cast::<u8>() = (22i32) as u8;
                                match e {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        let super::super::wasi::http::types::FieldSizePayload {
                                            field_name: field_name4,
                                            field_size: field_size4,
                                        } = e;
                                        match field_name4 {
                                            Some(e) => {
                                                *ptr
                                                    .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                    .cast::<u8>() = (1i32) as u8;
                                                let vec5 = (e.into_bytes()).into_boxed_slice();
                                                let ptr5 = vec5.as_ptr().cast::<u8>();
                                                let len5 = vec5.len();
                                                ::core::mem::forget(vec5);
                                                *ptr
                                                    .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                    .cast::<usize>() = len5;
                                                *ptr
                                                    .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                    .cast::<*mut u8>() = ptr5.cast_mut();
                                            }
                                            None => {
                                                *ptr
                                                    .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                    .cast::<u8>() = (0i32) as u8;
                                            }
                                        };
                                        match field_size4 {
                                            Some(e) => {
                                                *ptr
                                                    .add(16 + 4 * ::core::mem::size_of::<*const u8>())
                                                    .cast::<u8>() = (1i32) as u8;
                                                *ptr
                                                    .add(20 + 4 * ::core::mem::size_of::<*const u8>())
                                                    .cast::<i32>() = super::super::_rt::as_i32(e);
                                            }
                                            None => {
                                                *ptr
                                                    .add(16 + 4 * ::core::mem::size_of::<*const u8>())
                                                    .cast::<u8>() = (0i32) as u8;
                                            }
                                        };
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpRequestTrailerSectionSize(e) => {
                                *ptr.add(8).cast::<u8>() = (23i32) as u8;
                                match e {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        *ptr.add(20).cast::<i32>() = super::super::_rt::as_i32(e);
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpRequestTrailerSize(e) => {
                                *ptr.add(8).cast::<u8>() = (24i32) as u8;
                                let super::super::wasi::http::types::FieldSizePayload {
                                    field_name: field_name6,
                                    field_size: field_size6,
                                } = e;
                                match field_name6 {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        let vec7 = (e.into_bytes()).into_boxed_slice();
                                        let ptr7 = vec7.as_ptr().cast::<u8>();
                                        let len7 = vec7.len();
                                        ::core::mem::forget(vec7);
                                        *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>() = len7;
                                        *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>() = ptr7.cast_mut();
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                                match field_size6 {
                                    Some(e) => {
                                        *ptr
                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u8>() = (1i32) as u8;
                                        *ptr
                                            .add(20 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<i32>() = super::super::_rt::as_i32(e);
                                    }
                                    None => {
                                        *ptr
                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpResponseIncomplete => {
                                *ptr.add(8).cast::<u8>() = (25i32) as u8;
                            }
                            V15::HttpResponseHeaderSectionSize(e) => {
                                *ptr.add(8).cast::<u8>() = (26i32) as u8;
                                match e {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        *ptr.add(20).cast::<i32>() = super::super::_rt::as_i32(e);
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpResponseHeaderSize(e) => {
                                *ptr.add(8).cast::<u8>() = (27i32) as u8;
                                let super::super::wasi::http::types::FieldSizePayload {
                                    field_name: field_name8,
                                    field_size: field_size8,
                                } = e;
                                match field_name8 {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        let vec9 = (e.into_bytes()).into_boxed_slice();
                                        let ptr9 = vec9.as_ptr().cast::<u8>();
                                        let len9 = vec9.len();
                                        ::core::mem::forget(vec9);
                                        *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>() = len9;
                                        *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>() = ptr9.cast_mut();
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                                match field_size8 {
                                    Some(e) => {
                                        *ptr
                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u8>() = (1i32) as u8;
                                        *ptr
                                            .add(20 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<i32>() = super::super::_rt::as_i32(e);
                                    }
                                    None => {
                                        *ptr
                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpResponseBodySize(e) => {
                                *ptr.add(8).cast::<u8>() = (28i32) as u8;
                                match e {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        *ptr.add(24).cast::<i64>() = super::super::_rt::as_i64(e);
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpResponseTrailerSectionSize(e) => {
                                *ptr.add(8).cast::<u8>() = (29i32) as u8;
                                match e {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        *ptr.add(20).cast::<i32>() = super::super::_rt::as_i32(e);
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpResponseTrailerSize(e) => {
                                *ptr.add(8).cast::<u8>() = (30i32) as u8;
                                let super::super::wasi::http::types::FieldSizePayload {
                                    field_name: field_name10,
                                    field_size: field_size10,
                                } = e;
                                match field_name10 {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        let vec11 = (e.into_bytes()).into_boxed_slice();
                                        let ptr11 = vec11.as_ptr().cast::<u8>();
                                        let len11 = vec11.len();
                                        ::core::mem::forget(vec11);
                                        *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>() = len11;
                                        *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>() = ptr11.cast_mut();
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                                match field_size10 {
                                    Some(e) => {
                                        *ptr
                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u8>() = (1i32) as u8;
                                        *ptr
                                            .add(20 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<i32>() = super::super::_rt::as_i32(e);
                                    }
                                    None => {
                                        *ptr
                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpResponseTransferCoding(e) => {
                                *ptr.add(8).cast::<u8>() = (31i32) as u8;
                                match e {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        let vec12 = (e.into_bytes()).into_boxed_slice();
                                        let ptr12 = vec12.as_ptr().cast::<u8>();
                                        let len12 = vec12.len();
                                        ::core::mem::forget(vec12);
                                        *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>() = len12;
                                        *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>() = ptr12.cast_mut();
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpResponseContentCoding(e) => {
                                *ptr.add(8).cast::<u8>() = (32i32) as u8;
                                match e {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        let vec13 = (e.into_bytes()).into_boxed_slice();
                                        let ptr13 = vec13.as_ptr().cast::<u8>();
                                        let len13 = vec13.len();
                                        ::core::mem::forget(vec13);
                                        *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>() = len13;
                                        *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>() = ptr13.cast_mut();
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                            V15::HttpResponseTimeout => {
                                *ptr.add(8).cast::<u8>() = (33i32) as u8;
                            }
                            V15::HttpUpgradeFailed => {
                                *ptr.add(8).cast::<u8>() = (34i32) as u8;
                            }
                            V15::HttpProtocolError => {
                                *ptr.add(8).cast::<u8>() = (35i32) as u8;
                            }
                            V15::LoopDetected => {
                                *ptr.add(8).cast::<u8>() = (36i32) as u8;
                            }
                            V15::ConfigurationError => {
                                *ptr.add(8).cast::<u8>() = (37i32) as u8;
                            }
                            V15::InternalError(e) => {
                                *ptr.add(8).cast::<u8>() = (38i32) as u8;
                                match e {
                                    Some(e) => {
                                        *ptr.add(16).cast::<u8>() = (1i32) as u8;
                                        let vec14 = (e.into_bytes()).into_boxed_slice();
                                        let ptr14 = vec14.as_ptr().cast::<u8>();
                                        let len14 = vec14.len();
                                        ::core::mem::forget(vec14);
                                        *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>() = len14;
                                        *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>() = ptr14.cast_mut();
                                    }
                                    None => {
                                        *ptr.add(16).cast::<u8>() = (0i32) as u8;
                                    }
                                };
                            }
                        }
                    }
                };
            }
        }
        unsafe fn dealloc_lists(ptr: *mut u8) {
            unsafe {
                let l0 = i32::from(*ptr.add(0).cast::<u8>());
                match l0 {
                    0 => {}
                    _ => {
                        let l1 = i32::from(*ptr.add(8).cast::<u8>());
                        match l1 {
                            0 => {}
                            1 => {
                                let l2 = i32::from(*ptr.add(16).cast::<u8>());
                                match l2 {
                                    0 => {}
                                    _ => {
                                        let l3 = *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>();
                                        let l4 = *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>();
                                        super::super::_rt::cabi_dealloc(l3, l4, 1);
                                    }
                                }
                            }
                            2 => {}
                            3 => {}
                            4 => {}
                            5 => {}
                            6 => {}
                            7 => {}
                            8 => {}
                            9 => {}
                            10 => {}
                            11 => {}
                            12 => {}
                            13 => {}
                            14 => {
                                let l5 = i32::from(
                                    *ptr
                                        .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                        .cast::<u8>(),
                                );
                                match l5 {
                                    0 => {}
                                    _ => {
                                        let l6 = *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>();
                                        let l7 = *ptr
                                            .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>();
                                        super::super::_rt::cabi_dealloc(l6, l7, 1);
                                    }
                                }
                            }
                            15 => {}
                            16 => {}
                            17 => {}
                            18 => {}
                            19 => {}
                            20 => {}
                            21 => {}
                            22 => {
                                let l8 = i32::from(*ptr.add(16).cast::<u8>());
                                match l8 {
                                    0 => {}
                                    _ => {
                                        let l9 = i32::from(
                                            *ptr
                                                .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                                .cast::<u8>(),
                                        );
                                        match l9 {
                                            0 => {}
                                            _ => {
                                                let l10 = *ptr
                                                    .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                                    .cast::<*mut u8>();
                                                let l11 = *ptr
                                                    .add(16 + 3 * ::core::mem::size_of::<*const u8>())
                                                    .cast::<usize>();
                                                super::super::_rt::cabi_dealloc(l10, l11, 1);
                                            }
                                        }
                                    }
                                }
                            }
                            23 => {}
                            24 => {
                                let l12 = i32::from(*ptr.add(16).cast::<u8>());
                                match l12 {
                                    0 => {}
                                    _ => {
                                        let l13 = *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>();
                                        let l14 = *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>();
                                        super::super::_rt::cabi_dealloc(l13, l14, 1);
                                    }
                                }
                            }
                            25 => {}
                            26 => {}
                            27 => {
                                let l15 = i32::from(*ptr.add(16).cast::<u8>());
                                match l15 {
                                    0 => {}
                                    _ => {
                                        let l16 = *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>();
                                        let l17 = *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>();
                                        super::super::_rt::cabi_dealloc(l16, l17, 1);
                                    }
                                }
                            }
                            28 => {}
                            29 => {}
                            30 => {
                                let l18 = i32::from(*ptr.add(16).cast::<u8>());
                                match l18 {
                                    0 => {}
                                    _ => {
                                        let l19 = *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>();
                                        let l20 = *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>();
                                        super::super::_rt::cabi_dealloc(l19, l20, 1);
                                    }
                                }
                            }
                            31 => {
                                let l21 = i32::from(*ptr.add(16).cast::<u8>());
                                match l21 {
                                    0 => {}
                                    _ => {
                                        let l22 = *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>();
                                        let l23 = *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>();
                                        super::super::_rt::cabi_dealloc(l22, l23, 1);
                                    }
                                }
                            }
                            32 => {
                                let l24 = i32::from(*ptr.add(16).cast::<u8>());
                                match l24 {
                                    0 => {}
                                    _ => {
                                        let l25 = *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>();
                                        let l26 = *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>();
                                        super::super::_rt::cabi_dealloc(l25, l26, 1);
                                    }
                                }
                            }
                            33 => {}
                            34 => {}
                            35 => {}
                            36 => {}
                            37 => {}
                            _ => {
                                let l27 = i32::from(*ptr.add(16).cast::<u8>());
                                match l27 {
                                    0 => {}
                                    _ => {
                                        let l28 = *ptr
                                            .add(16 + 1 * ::core::mem::size_of::<*const u8>())
                                            .cast::<*mut u8>();
                                        let l29 = *ptr
                                            .add(16 + 2 * ::core::mem::size_of::<*const u8>())
                                            .cast::<usize>();
                                        super::super::_rt::cabi_dealloc(l28, l29, 1);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        pub static VTABLE: wit_bindgen::rt::async_support::FutureVtable<
            Result<(), super::super::wasi::http::types::ErrorCode>,
        > = wit_bindgen::rt::async_support::FutureVtable::<
            Result<(), super::super::wasi::http::types::ErrorCode>,
        > {
            cancel_write,
            cancel_read,
            drop_writable,
            drop_readable,
            dealloc_lists,
            layout: unsafe { ::std::alloc::Layout::from_size_align_unchecked(40, 8) },
            lift,
            lower,
            new,
            start_read,
            start_write,
        };
        impl super::FuturePayload
        for Result<(), super::super::wasi::http::types::ErrorCode> {
            const VTABLE: &'static wit_bindgen::rt::async_support::FutureVtable<Self> = &VTABLE;
        }
    }
    /// Creates a new Component Model `future` with the specified payload type.
    ///
    /// The `default` function provided computes the default value to be sent in
    /// this future if no other value was otherwise sent.
    pub fn new<T: FuturePayload>(
        default: fn() -> T,
    ) -> (
        wit_bindgen::rt::async_support::FutureWriter<T>,
        wit_bindgen::rt::async_support::FutureReader<T>,
    ) {
        unsafe { wit_bindgen::rt::async_support::future_new::<T>(default, T::VTABLE) }
    }
}
pub mod wit_stream {
    #![allow(dead_code, unused_variables, clippy::all)]
    pub trait StreamPayload: Unpin + Sized + 'static {
        const VTABLE: &'static wit_bindgen::rt::async_support::StreamVtable<Self>;
    }
    #[doc(hidden)]
    #[allow(unused_unsafe)]
    pub mod vtable0 {
        #[cfg(not(target_arch = "wasm32"))]
        unsafe extern "C" fn cancel_write(_: u32) -> u32 {
            unreachable!()
        }
        #[cfg(not(target_arch = "wasm32"))]
        unsafe extern "C" fn cancel_read(_: u32) -> u32 {
            unreachable!()
        }
        #[cfg(not(target_arch = "wasm32"))]
        unsafe extern "C" fn drop_writable(_: u32) {
            unreachable!()
        }
        #[cfg(not(target_arch = "wasm32"))]
        unsafe extern "C" fn drop_readable(_: u32) {
            unreachable!()
        }
        #[cfg(not(target_arch = "wasm32"))]
        unsafe extern "C" fn new() -> u64 {
            unreachable!()
        }
        #[cfg(not(target_arch = "wasm32"))]
        unsafe extern "C" fn start_read(_: u32, _: *mut u8, _: usize) -> u32 {
            unreachable!()
        }
        #[cfg(not(target_arch = "wasm32"))]
        unsafe extern "C" fn start_write(_: u32, _: *const u8, _: usize) -> u32 {
            unreachable!()
        }
        #[cfg(target_arch = "wasm32")]
        #[link(wasm_import_module = "wasi:http/types@0.3.0-rc-2026-01-06")]
        unsafe extern "C" {
            #[link_name = "[stream-new-0][static]request.new"]
            fn new() -> u64;
            #[link_name = "[stream-cancel-write-0][static]request.new"]
            fn cancel_write(_: u32) -> u32;
            #[link_name = "[stream-cancel-read-0][static]request.new"]
            fn cancel_read(_: u32) -> u32;
            #[link_name = "[stream-drop-writable-0][static]request.new"]
            fn drop_writable(_: u32);
            #[link_name = "[stream-drop-readable-0][static]request.new"]
            fn drop_readable(_: u32);
            #[link_name = "[async-lower][stream-read-0][static]request.new"]
            fn start_read(_: u32, _: *mut u8, _: usize) -> u32;
            #[link_name = "[async-lower][stream-write-0][static]request.new"]
            fn start_write(_: u32, _: *const u8, _: usize) -> u32;
        }
        pub static VTABLE: wit_bindgen::rt::async_support::StreamVtable<u8> = wit_bindgen::rt::async_support::StreamVtable::<
            u8,
        > {
            cancel_write,
            cancel_read,
            drop_writable,
            drop_readable,
            dealloc_lists: None,
            layout: unsafe { ::std::alloc::Layout::from_size_align_unchecked(1, 1) },
            lift: None,
            lower: None,
            new,
            start_read,
            start_write,
        };
        impl super::StreamPayload for u8 {
            const VTABLE: &'static wit_bindgen::rt::async_support::StreamVtable<Self> = &VTABLE;
        }
    }
    /// Creates a new Component Model `stream` with the specified payload type.
    pub fn new<T: StreamPayload>() -> (
        wit_bindgen::rt::async_support::StreamWriter<T>,
        wit_bindgen::rt::async_support::StreamReader<T>,
    ) {
        unsafe { wit_bindgen::rt::async_support::stream_new::<T>(T::VTABLE) }
    }
}
/// Generates `#[unsafe(no_mangle)]` functions to export the specified type as
/// the root implementation of all generated traits.
///
/// For more information see the documentation of `wit_bindgen::generate!`.
///
/// ```rust
/// # macro_rules! _export_service{ ($($t:tt)*) => (); }
/// # trait Guest {}
/// struct MyType;
///
/// impl Guest for MyType {
///     // ...
/// }
///
/// _export_service!(MyType);
/// ```
#[allow(unused_macros)]
#[doc(hidden)]
#[macro_export]
macro_rules! __export_service_impl {
    ($ty:ident) => {
        $crate::_export_service!($ty with_types_in $crate);
    };
    ($ty:ident with_types_in $($path_to_types_root:tt)*) => {
        $($path_to_types_root)*::
        exports::wasi::http::handler::__export_wasi_http_handler_0_3_0_rc_2026_01_06_cabi!($ty
        with_types_in $($path_to_types_root)*:: exports::wasi::http::handler); const _ :
        () = { #[rustfmt::skip] #[cfg(target_arch = "wasm32")] #[unsafe (link_section =
        "component-type:wit-bindgen:0.51.0:wasi:http@0.3.0-rc-2026-01-06:service:imports and exportsrust-wasip3-0.4.0+wasi-0.3.0-rc-2026-01-06-from-crates-io-service-world")]
        #[doc(hidden)] #[allow(clippy::octal_escapes)] pub static
        __WIT_BINDGEN_COMPONENT_TYPE : [u8; 5141] = *
        b"\
\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\x97'\x01A\x02\x01A\x1f\
\x01B\x02\x01m\x03\x02io\x15illegal-byte-sequence\x04pipe\x04\0\x0aerror-code\x03\
\0\0\x03\0\"wasi:cli/types@0.3.0-rc-2026-01-06\x05\0\x02\x03\0\0\x0aerror-code\x01\
B\x06\x02\x03\x02\x01\x01\x04\0\x0aerror-code\x03\0\0\x01f\x01}\x01j\0\x01\x01\x01\
C\x01\x04data\x02\0\x03\x04\0\x10write-via-stream\x01\x04\x03\0#wasi:cli/stdout@\
0.3.0-rc-2026-01-06\x05\x02\x01B\x06\x02\x03\x02\x01\x01\x04\0\x0aerror-code\x03\
\0\0\x01f\x01}\x01j\0\x01\x01\x01C\x01\x04data\x02\0\x03\x04\0\x10write-via-stre\
am\x01\x04\x03\0#wasi:cli/stderr@0.3.0-rc-2026-01-06\x05\x03\x01B\x08\x02\x03\x02\
\x01\x01\x04\0\x0aerror-code\x03\0\0\x01f\x01}\x01j\0\x01\x01\x01e\x01\x03\x01o\x02\
\x02\x04\x01@\0\0\x05\x04\0\x0fread-via-stream\x01\x06\x03\0\"wasi:cli/stdin@0.3\
.0-rc-2026-01-06\x05\x04\x01B\x02\x01w\x04\0\x08duration\x03\0\0\x03\0%wasi:cloc\
ks/types@0.3.0-rc-2026-01-06\x05\x05\x02\x03\0\x04\x08duration\x01B\x84\x01\x02\x03\
\x02\x01\x06\x04\0\x08duration\x03\0\0\x01q\x0a\x03get\0\0\x04head\0\0\x04post\0\
\0\x03put\0\0\x06delete\0\0\x07connect\0\0\x07options\0\0\x05trace\0\0\x05patch\0\
\0\x05other\x01s\0\x04\0\x06method\x03\0\x02\x01q\x03\x04HTTP\0\0\x05HTTPS\0\0\x05\
other\x01s\0\x04\0\x06scheme\x03\0\x04\x01ks\x01k{\x01r\x02\x05rcode\x06\x09info\
-code\x07\x04\0\x11DNS-error-payload\x03\0\x08\x01k}\x01r\x02\x08alert-id\x0a\x0d\
alert-message\x06\x04\0\x1aTLS-alert-received-payload\x03\0\x0b\x01ky\x01r\x02\x0a\
field-name\x06\x0afield-size\x0d\x04\0\x12field-size-payload\x03\0\x0e\x01kw\x01\
k\x0f\x01q'\x0bDNS-timeout\0\0\x09DNS-error\x01\x09\0\x15destination-not-found\0\
\0\x17destination-unavailable\0\0\x19destination-IP-prohibited\0\0\x19destinatio\
n-IP-unroutable\0\0\x12connection-refused\0\0\x15connection-terminated\0\0\x12co\
nnection-timeout\0\0\x17connection-read-timeout\0\0\x18connection-write-timeout\0\
\0\x18connection-limit-reached\0\0\x12TLS-protocol-error\0\0\x15TLS-certificate-\
error\0\0\x12TLS-alert-received\x01\x0c\0\x13HTTP-request-denied\0\0\x1cHTTP-req\
uest-length-required\0\0\x16HTTP-request-body-size\x01\x10\0\x1bHTTP-request-met\
hod-invalid\0\0\x18HTTP-request-URI-invalid\0\0\x19HTTP-request-URI-too-long\0\0\
\x20HTTP-request-header-section-size\x01\x0d\0\x18HTTP-request-header-size\x01\x11\
\0!HTTP-request-trailer-section-size\x01\x0d\0\x19HTTP-request-trailer-size\x01\x0f\
\0\x18HTTP-response-incomplete\0\0!HTTP-response-header-section-size\x01\x0d\0\x19\
HTTP-response-header-size\x01\x0f\0\x17HTTP-response-body-size\x01\x10\0\"HTTP-r\
esponse-trailer-section-size\x01\x0d\0\x1aHTTP-response-trailer-size\x01\x0f\0\x1d\
HTTP-response-transfer-coding\x01\x06\0\x1cHTTP-response-content-coding\x01\x06\0\
\x15HTTP-response-timeout\0\0\x13HTTP-upgrade-failed\0\0\x13HTTP-protocol-error\0\
\0\x0dloop-detected\0\0\x13configuration-error\0\0\x0einternal-error\x01\x06\0\x04\
\0\x0aerror-code\x03\0\x12\x01q\x03\x0einvalid-syntax\0\0\x09forbidden\0\0\x09im\
mutable\0\0\x04\0\x0cheader-error\x03\0\x14\x01q\x02\x0dnot-supported\0\0\x09imm\
utable\0\0\x04\0\x15request-options-error\x03\0\x16\x01s\x04\0\x0afield-name\x03\
\0\x18\x01p}\x04\0\x0bfield-value\x03\0\x1a\x04\0\x06fields\x03\x01\x04\0\x07hea\
ders\x03\0\x1c\x04\0\x08trailers\x03\0\x1c\x04\0\x07request\x03\x01\x04\0\x0freq\
uest-options\x03\x01\x01{\x04\0\x0bstatus-code\x03\0!\x04\0\x08response\x03\x01\x01\
i\x1c\x01@\0\0$\x04\0\x13[constructor]fields\x01%\x01o\x02\x19\x1b\x01p&\x01j\x01\
$\x01\x15\x01@\x01\x07entries'\0(\x04\0\x18[static]fields.from-list\x01)\x01h\x1c\
\x01p\x1b\x01@\x02\x04self*\x04name\x19\0+\x04\0\x12[method]fields.get\x01,\x01@\
\x02\x04self*\x04name\x19\0\x7f\x04\0\x12[method]fields.has\x01-\x01j\0\x01\x15\x01\
@\x03\x04self*\x04name\x19\x05value+\0.\x04\0\x12[method]fields.set\x01/\x01@\x02\
\x04self*\x04name\x19\0.\x04\0\x15[method]fields.delete\x010\x01j\x01+\x01\x15\x01\
@\x02\x04self*\x04name\x19\01\x04\0\x1d[method]fields.get-and-delete\x012\x01@\x03\
\x04self*\x04name\x19\x05value\x1b\0.\x04\0\x15[method]fields.append\x013\x01@\x01\
\x04self*\0'\x04\0\x17[method]fields.copy-all\x014\x01@\x01\x04self*\0$\x04\0\x14\
[method]fields.clone\x015\x01i\x1d\x01f\x01}\x01k7\x01i\x1e\x01k9\x01j\x01:\x01\x13\
\x01e\x01;\x01i\x20\x01k=\x01i\x1f\x01j\0\x01\x13\x01e\x01\xc0\0\x01o\x02?\xc1\0\
\x01@\x04\x07headers6\x08contents8\x08trailers<\x07options>\0\xc2\0\x04\0\x13[st\
atic]request.new\x01C\x01h\x1f\x01@\x01\x04self\xc4\0\0\x03\x04\0\x1a[method]req\
uest.get-method\x01E\x01j\0\0\x01@\x02\x04self\xc4\0\x06method\x03\0\xc6\0\x04\0\
\x1a[method]request.set-method\x01G\x01@\x01\x04self\xc4\0\0\x06\x04\0#[method]r\
equest.get-path-with-query\x01H\x01@\x02\x04self\xc4\0\x0fpath-with-query\x06\0\xc6\
\0\x04\0#[method]request.set-path-with-query\x01I\x01k\x05\x01@\x01\x04self\xc4\0\
\0\xca\0\x04\0\x1a[method]request.get-scheme\x01K\x01@\x02\x04self\xc4\0\x06sche\
me\xca\0\0\xc6\0\x04\0\x1a[method]request.set-scheme\x01L\x04\0\x1d[method]reque\
st.get-authority\x01H\x01@\x02\x04self\xc4\0\x09authority\x06\0\xc6\0\x04\0\x1d[\
method]request.set-authority\x01M\x01@\x01\x04self\xc4\0\0>\x04\0\x1b[method]req\
uest.get-options\x01N\x01@\x01\x04self\xc4\0\06\x04\0\x1b[method]request.get-hea\
ders\x01O\x01o\x027<\x01@\x02\x04this?\x03res\xc1\0\0\xd0\0\x04\0\x1c[static]req\
uest.consume-body\x01Q\x01@\0\0=\x04\0\x1c[constructor]request-options\x01R\x01h\
\x20\x01k\x01\x01@\x01\x04self\xd3\0\0\xd4\0\x04\0+[method]request-options.get-c\
onnect-timeout\x01U\x01j\0\x01\x17\x01@\x02\x04self\xd3\0\x08duration\xd4\0\0\xd6\
\0\x04\0+[method]request-options.set-connect-timeout\x01W\x04\0.[method]request-\
options.get-first-byte-timeout\x01U\x04\0.[method]request-options.set-first-byte\
-timeout\x01W\x04\01[method]request-options.get-between-bytes-timeout\x01U\x04\0\
1[method]request-options.set-between-bytes-timeout\x01W\x01@\x01\x04self\xd3\0\0\
=\x04\0\x1d[method]request-options.clone\x01X\x01i#\x01o\x02\xd9\0\xc1\0\x01@\x03\
\x07headers6\x08contents8\x08trailers<\0\xda\0\x04\0\x14[static]response.new\x01\
[\x01h#\x01@\x01\x04self\xdc\0\0\"\x04\0\x20[method]response.get-status-code\x01\
]\x01@\x02\x04self\xdc\0\x0bstatus-code\"\0\xc6\0\x04\0\x20[method]response.set-\
status-code\x01^\x01@\x01\x04self\xdc\0\06\x04\0\x1c[method]response.get-headers\
\x01_\x01@\x02\x04this\xd9\0\x03res\xc1\0\0\xd0\0\x04\0\x1d[static]response.cons\
ume-body\x01`\x03\0#wasi:http/types@0.3.0-rc-2026-01-06\x05\x07\x02\x03\0\x05\x07\
request\x02\x03\0\x05\x08response\x02\x03\0\x05\x0aerror-code\x01B\x0b\x02\x03\x02\
\x01\x08\x04\0\x07request\x03\0\0\x02\x03\x02\x01\x09\x04\0\x08response\x03\0\x02\
\x02\x03\x02\x01\x0a\x04\0\x0aerror-code\x03\0\x04\x01i\x01\x01i\x03\x01j\x01\x07\
\x01\x05\x01C\x01\x07request\x06\0\x08\x04\0\x04send\x01\x09\x03\0$wasi:http/cli\
ent@0.3.0-rc-2026-01-06\x05\x0b\x01B\x0c\x02\x03\x02\x01\x06\x04\0\x08duration\x03\
\0\0\x01w\x04\0\x04mark\x03\0\x02\x01@\0\0\x03\x04\0\x03now\x01\x04\x01@\0\0\x01\
\x04\0\x0eget-resolution\x01\x05\x01C\x01\x04when\x03\x01\0\x04\0\x0await-until\x01\
\x06\x01C\x01\x08how-long\x01\x01\0\x04\0\x08wait-for\x01\x07\x03\0/wasi:clocks/\
monotonic-clock@0.3.0-rc-2026-01-06\x05\x0c\x01B\x08\x02\x03\x02\x01\x06\x04\0\x08\
duration\x03\0\0\x01r\x02\x07secondsx\x0bnanosecondsy\x04\0\x07instant\x03\0\x02\
\x01@\0\0\x03\x04\0\x03now\x01\x04\x01@\0\0\x01\x04\0\x0eget-resolution\x01\x05\x03\
\0,wasi:clocks/system-clock@0.3.0-rc-2026-01-06\x05\x0d\x01B\x05\x01p}\x01@\x01\x03\
lenw\0\0\x04\0\x10get-random-bytes\x01\x01\x01@\0\0w\x04\0\x0eget-random-u64\x01\
\x02\x03\0&wasi:random/random@0.3.0-rc-2026-01-06\x05\x0e\x01B\x05\x01p}\x01@\x01\
\x03lenw\0\0\x04\0\x19get-insecure-random-bytes\x01\x01\x01@\0\0w\x04\0\x17get-i\
nsecure-random-u64\x01\x02\x03\0(wasi:random/insecure@0.3.0-rc-2026-01-06\x05\x0f\
\x01B\x03\x01o\x02ww\x01@\0\0\0\x04\0\x11get-insecure-seed\x01\x01\x03\0-wasi:ra\
ndom/insecure-seed@0.3.0-rc-2026-01-06\x05\x10\x01B\x0b\x02\x03\x02\x01\x08\x04\0\
\x07request\x03\0\0\x02\x03\x02\x01\x09\x04\0\x08response\x03\0\x02\x02\x03\x02\x01\
\x0a\x04\0\x0aerror-code\x03\0\x04\x01i\x01\x01i\x03\x01j\x01\x07\x01\x05\x01C\x01\
\x07request\x06\0\x08\x04\0\x06handle\x01\x09\x04\0%wasi:http/handler@0.3.0-rc-2\
026-01-06\x05\x11\x04\0%wasi:http/service@0.3.0-rc-2026-01-06\x04\0\x0b\x0d\x01\0\
\x07service\x03\0\0\0G\x09producers\x01\x0cprocessed-by\x02\x0dwit-component\x07\
0.244.0\x10wit-bindgen-rust\x060.51.0";
        };
    };
}
#[doc(inline)]
pub use __export_service_impl as _export_service;
#[rustfmt::skip]
#[cfg(target_arch = "wasm32")]
#[unsafe(
    link_section = "component-type:wit-bindgen:0.51.0:wasi:http@0.3.0-rc-2026-01-06:service-with-all-of-its-exports-removed:encoded worldrust-wasip3-0.4.0+wasi-0.3.0-rc-2026-01-06-from-crates-io-service-world"
)]
#[doc(hidden)]
#[allow(clippy::octal_escapes)]
pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 5065] = *b"\
\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\xab&\x01A\x02\x01A\x1d\
\x01B\x02\x01m\x03\x02io\x15illegal-byte-sequence\x04pipe\x04\0\x0aerror-code\x03\
\0\0\x03\0\"wasi:cli/types@0.3.0-rc-2026-01-06\x05\0\x02\x03\0\0\x0aerror-code\x01\
B\x06\x02\x03\x02\x01\x01\x04\0\x0aerror-code\x03\0\0\x01f\x01}\x01j\0\x01\x01\x01\
C\x01\x04data\x02\0\x03\x04\0\x10write-via-stream\x01\x04\x03\0#wasi:cli/stdout@\
0.3.0-rc-2026-01-06\x05\x02\x01B\x06\x02\x03\x02\x01\x01\x04\0\x0aerror-code\x03\
\0\0\x01f\x01}\x01j\0\x01\x01\x01C\x01\x04data\x02\0\x03\x04\0\x10write-via-stre\
am\x01\x04\x03\0#wasi:cli/stderr@0.3.0-rc-2026-01-06\x05\x03\x01B\x08\x02\x03\x02\
\x01\x01\x04\0\x0aerror-code\x03\0\0\x01f\x01}\x01j\0\x01\x01\x01e\x01\x03\x01o\x02\
\x02\x04\x01@\0\0\x05\x04\0\x0fread-via-stream\x01\x06\x03\0\"wasi:cli/stdin@0.3\
.0-rc-2026-01-06\x05\x04\x01B\x02\x01w\x04\0\x08duration\x03\0\0\x03\0%wasi:cloc\
ks/types@0.3.0-rc-2026-01-06\x05\x05\x02\x03\0\x04\x08duration\x01B\x84\x01\x02\x03\
\x02\x01\x06\x04\0\x08duration\x03\0\0\x01q\x0a\x03get\0\0\x04head\0\0\x04post\0\
\0\x03put\0\0\x06delete\0\0\x07connect\0\0\x07options\0\0\x05trace\0\0\x05patch\0\
\0\x05other\x01s\0\x04\0\x06method\x03\0\x02\x01q\x03\x04HTTP\0\0\x05HTTPS\0\0\x05\
other\x01s\0\x04\0\x06scheme\x03\0\x04\x01ks\x01k{\x01r\x02\x05rcode\x06\x09info\
-code\x07\x04\0\x11DNS-error-payload\x03\0\x08\x01k}\x01r\x02\x08alert-id\x0a\x0d\
alert-message\x06\x04\0\x1aTLS-alert-received-payload\x03\0\x0b\x01ky\x01r\x02\x0a\
field-name\x06\x0afield-size\x0d\x04\0\x12field-size-payload\x03\0\x0e\x01kw\x01\
k\x0f\x01q'\x0bDNS-timeout\0\0\x09DNS-error\x01\x09\0\x15destination-not-found\0\
\0\x17destination-unavailable\0\0\x19destination-IP-prohibited\0\0\x19destinatio\
n-IP-unroutable\0\0\x12connection-refused\0\0\x15connection-terminated\0\0\x12co\
nnection-timeout\0\0\x17connection-read-timeout\0\0\x18connection-write-timeout\0\
\0\x18connection-limit-reached\0\0\x12TLS-protocol-error\0\0\x15TLS-certificate-\
error\0\0\x12TLS-alert-received\x01\x0c\0\x13HTTP-request-denied\0\0\x1cHTTP-req\
uest-length-required\0\0\x16HTTP-request-body-size\x01\x10\0\x1bHTTP-request-met\
hod-invalid\0\0\x18HTTP-request-URI-invalid\0\0\x19HTTP-request-URI-too-long\0\0\
\x20HTTP-request-header-section-size\x01\x0d\0\x18HTTP-request-header-size\x01\x11\
\0!HTTP-request-trailer-section-size\x01\x0d\0\x19HTTP-request-trailer-size\x01\x0f\
\0\x18HTTP-response-incomplete\0\0!HTTP-response-header-section-size\x01\x0d\0\x19\
HTTP-response-header-size\x01\x0f\0\x17HTTP-response-body-size\x01\x10\0\"HTTP-r\
esponse-trailer-section-size\x01\x0d\0\x1aHTTP-response-trailer-size\x01\x0f\0\x1d\
HTTP-response-transfer-coding\x01\x06\0\x1cHTTP-response-content-coding\x01\x06\0\
\x15HTTP-response-timeout\0\0\x13HTTP-upgrade-failed\0\0\x13HTTP-protocol-error\0\
\0\x0dloop-detected\0\0\x13configuration-error\0\0\x0einternal-error\x01\x06\0\x04\
\0\x0aerror-code\x03\0\x12\x01q\x03\x0einvalid-syntax\0\0\x09forbidden\0\0\x09im\
mutable\0\0\x04\0\x0cheader-error\x03\0\x14\x01q\x02\x0dnot-supported\0\0\x09imm\
utable\0\0\x04\0\x15request-options-error\x03\0\x16\x01s\x04\0\x0afield-name\x03\
\0\x18\x01p}\x04\0\x0bfield-value\x03\0\x1a\x04\0\x06fields\x03\x01\x04\0\x07hea\
ders\x03\0\x1c\x04\0\x08trailers\x03\0\x1c\x04\0\x07request\x03\x01\x04\0\x0freq\
uest-options\x03\x01\x01{\x04\0\x0bstatus-code\x03\0!\x04\0\x08response\x03\x01\x01\
i\x1c\x01@\0\0$\x04\0\x13[constructor]fields\x01%\x01o\x02\x19\x1b\x01p&\x01j\x01\
$\x01\x15\x01@\x01\x07entries'\0(\x04\0\x18[static]fields.from-list\x01)\x01h\x1c\
\x01p\x1b\x01@\x02\x04self*\x04name\x19\0+\x04\0\x12[method]fields.get\x01,\x01@\
\x02\x04self*\x04name\x19\0\x7f\x04\0\x12[method]fields.has\x01-\x01j\0\x01\x15\x01\
@\x03\x04self*\x04name\x19\x05value+\0.\x04\0\x12[method]fields.set\x01/\x01@\x02\
\x04self*\x04name\x19\0.\x04\0\x15[method]fields.delete\x010\x01j\x01+\x01\x15\x01\
@\x02\x04self*\x04name\x19\01\x04\0\x1d[method]fields.get-and-delete\x012\x01@\x03\
\x04self*\x04name\x19\x05value\x1b\0.\x04\0\x15[method]fields.append\x013\x01@\x01\
\x04self*\0'\x04\0\x17[method]fields.copy-all\x014\x01@\x01\x04self*\0$\x04\0\x14\
[method]fields.clone\x015\x01i\x1d\x01f\x01}\x01k7\x01i\x1e\x01k9\x01j\x01:\x01\x13\
\x01e\x01;\x01i\x20\x01k=\x01i\x1f\x01j\0\x01\x13\x01e\x01\xc0\0\x01o\x02?\xc1\0\
\x01@\x04\x07headers6\x08contents8\x08trailers<\x07options>\0\xc2\0\x04\0\x13[st\
atic]request.new\x01C\x01h\x1f\x01@\x01\x04self\xc4\0\0\x03\x04\0\x1a[method]req\
uest.get-method\x01E\x01j\0\0\x01@\x02\x04self\xc4\0\x06method\x03\0\xc6\0\x04\0\
\x1a[method]request.set-method\x01G\x01@\x01\x04self\xc4\0\0\x06\x04\0#[method]r\
equest.get-path-with-query\x01H\x01@\x02\x04self\xc4\0\x0fpath-with-query\x06\0\xc6\
\0\x04\0#[method]request.set-path-with-query\x01I\x01k\x05\x01@\x01\x04self\xc4\0\
\0\xca\0\x04\0\x1a[method]request.get-scheme\x01K\x01@\x02\x04self\xc4\0\x06sche\
me\xca\0\0\xc6\0\x04\0\x1a[method]request.set-scheme\x01L\x04\0\x1d[method]reque\
st.get-authority\x01H\x01@\x02\x04self\xc4\0\x09authority\x06\0\xc6\0\x04\0\x1d[\
method]request.set-authority\x01M\x01@\x01\x04self\xc4\0\0>\x04\0\x1b[method]req\
uest.get-options\x01N\x01@\x01\x04self\xc4\0\06\x04\0\x1b[method]request.get-hea\
ders\x01O\x01o\x027<\x01@\x02\x04this?\x03res\xc1\0\0\xd0\0\x04\0\x1c[static]req\
uest.consume-body\x01Q\x01@\0\0=\x04\0\x1c[constructor]request-options\x01R\x01h\
\x20\x01k\x01\x01@\x01\x04self\xd3\0\0\xd4\0\x04\0+[method]request-options.get-c\
onnect-timeout\x01U\x01j\0\x01\x17\x01@\x02\x04self\xd3\0\x08duration\xd4\0\0\xd6\
\0\x04\0+[method]request-options.set-connect-timeout\x01W\x04\0.[method]request-\
options.get-first-byte-timeout\x01U\x04\0.[method]request-options.set-first-byte\
-timeout\x01W\x04\01[method]request-options.get-between-bytes-timeout\x01U\x04\0\
1[method]request-options.set-between-bytes-timeout\x01W\x01@\x01\x04self\xd3\0\0\
=\x04\0\x1d[method]request-options.clone\x01X\x01i#\x01o\x02\xd9\0\xc1\0\x01@\x03\
\x07headers6\x08contents8\x08trailers<\0\xda\0\x04\0\x14[static]response.new\x01\
[\x01h#\x01@\x01\x04self\xdc\0\0\"\x04\0\x20[method]response.get-status-code\x01\
]\x01@\x02\x04self\xdc\0\x0bstatus-code\"\0\xc6\0\x04\0\x20[method]response.set-\
status-code\x01^\x01@\x01\x04self\xdc\0\06\x04\0\x1c[method]response.get-headers\
\x01_\x01@\x02\x04this\xd9\0\x03res\xc1\0\0\xd0\0\x04\0\x1d[static]response.cons\
ume-body\x01`\x03\0#wasi:http/types@0.3.0-rc-2026-01-06\x05\x07\x02\x03\0\x05\x07\
request\x02\x03\0\x05\x08response\x02\x03\0\x05\x0aerror-code\x01B\x0b\x02\x03\x02\
\x01\x08\x04\0\x07request\x03\0\0\x02\x03\x02\x01\x09\x04\0\x08response\x03\0\x02\
\x02\x03\x02\x01\x0a\x04\0\x0aerror-code\x03\0\x04\x01i\x01\x01i\x03\x01j\x01\x07\
\x01\x05\x01C\x01\x07request\x06\0\x08\x04\0\x04send\x01\x09\x03\0$wasi:http/cli\
ent@0.3.0-rc-2026-01-06\x05\x0b\x01B\x0c\x02\x03\x02\x01\x06\x04\0\x08duration\x03\
\0\0\x01w\x04\0\x04mark\x03\0\x02\x01@\0\0\x03\x04\0\x03now\x01\x04\x01@\0\0\x01\
\x04\0\x0eget-resolution\x01\x05\x01C\x01\x04when\x03\x01\0\x04\0\x0await-until\x01\
\x06\x01C\x01\x08how-long\x01\x01\0\x04\0\x08wait-for\x01\x07\x03\0/wasi:clocks/\
monotonic-clock@0.3.0-rc-2026-01-06\x05\x0c\x01B\x08\x02\x03\x02\x01\x06\x04\0\x08\
duration\x03\0\0\x01r\x02\x07secondsx\x0bnanosecondsy\x04\0\x07instant\x03\0\x02\
\x01@\0\0\x03\x04\0\x03now\x01\x04\x01@\0\0\x01\x04\0\x0eget-resolution\x01\x05\x03\
\0,wasi:clocks/system-clock@0.3.0-rc-2026-01-06\x05\x0d\x01B\x05\x01p}\x01@\x01\x03\
lenw\0\0\x04\0\x10get-random-bytes\x01\x01\x01@\0\0w\x04\0\x0eget-random-u64\x01\
\x02\x03\0&wasi:random/random@0.3.0-rc-2026-01-06\x05\x0e\x01B\x05\x01p}\x01@\x01\
\x03lenw\0\0\x04\0\x19get-insecure-random-bytes\x01\x01\x01@\0\0w\x04\0\x17get-i\
nsecure-random-u64\x01\x02\x03\0(wasi:random/insecure@0.3.0-rc-2026-01-06\x05\x0f\
\x01B\x03\x01o\x02ww\x01@\0\0\0\x04\0\x11get-insecure-seed\x01\x01\x03\0-wasi:ra\
ndom/insecure-seed@0.3.0-rc-2026-01-06\x05\x10\x04\0Ewasi:http/service-with-all-\
of-its-exports-removed@0.3.0-rc-2026-01-06\x04\0\x0b-\x01\0'service-with-all-of-\
its-exports-removed\x03\0\0\0G\x09producers\x01\x0cprocessed-by\x02\x0dwit-compo\
nent\x070.244.0\x10wit-bindgen-rust\x060.51.0";
#[inline(never)]
#[doc(hidden)]
pub fn __link_custom_section_describing_imports() {
    wit_bindgen::rt::maybe_link_cabi_realloc();
}
