golem_rust/

bindings.rs

// Generated by `wit-bindgen` 0.36.0. DO NOT EDIT!
// Options used:
//   * runtime_path: "wit_bindgen_rt"
#[rustfmt::skip]
#[allow(dead_code, clippy::all)]
pub mod golem {
    pub mod api {
        /// The Golem host API provides low level access to Golem specific features such as promises and control over
        /// the durability and transactional guarantees the executor provides.
        #[allow(dead_code, clippy::all)]
        pub mod host {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            use super::super::super::_rt;
            pub type Uri = super::super::super::golem::rpc::types::Uri;
            pub type Duration = super::super::super::wasi::clocks::monotonic_clock::Duration;
            /// An index into the persistent log storing all performed operations of a worker
            pub type OplogIndex = u64;
            /// Represents a Golem component's version
            pub type ComponentVersion = u64;
            /// UUID
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct Uuid {
                pub high_bits: u64,
                pub low_bits: u64,
            }
            impl ::core::fmt::Debug for Uuid {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Uuid")
                        .field("high-bits", &self.high_bits)
                        .field("low-bits", &self.low_bits)
                        .finish()
                }
            }
            /// Represents a Golem component
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct ComponentId {
                pub uuid: Uuid,
            }
            impl ::core::fmt::Debug for ComponentId {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("ComponentId").field("uuid", &self.uuid).finish()
                }
            }
            /// Represents a Golem worker
            #[derive(Clone)]
            pub struct WorkerId {
                pub component_id: ComponentId,
                pub worker_name: _rt::String,
            }
            impl ::core::fmt::Debug for WorkerId {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("WorkerId")
                        .field("component-id", &self.component_id)
                        .field("worker-name", &self.worker_name)
                        .finish()
                }
            }
            /// A promise ID is a value that can be passed to an external Golem API to complete that promise
            /// from an arbitrary external source, while Golem workers can await for this completion.
            #[derive(Clone)]
            pub struct PromiseId {
                pub worker_id: WorkerId,
                pub oplog_idx: OplogIndex,
            }
            impl ::core::fmt::Debug for PromiseId {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("PromiseId")
                        .field("worker-id", &self.worker_id)
                        .field("oplog-idx", &self.oplog_idx)
                        .finish()
                }
            }
            /// Represents a Golem Cloud account
            #[derive(Clone)]
            pub struct AccountId {
                pub value: _rt::String,
            }
            impl ::core::fmt::Debug for AccountId {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("AccountId").field("value", &self.value).finish()
                }
            }
            /// Configures how the executor retries failures
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct RetryPolicy {
                /// The maximum number of retries before the worker becomes permanently failed
                pub max_attempts: u32,
                /// The minimum delay between retries (applied to the first retry)
                pub min_delay: Duration,
                /// The maximum delay between retries
                pub max_delay: Duration,
                /// Multiplier applied to the delay on each retry to implement exponential backoff
                pub multiplier: f64,
                /// The maximum amount of jitter to add to the delay
                pub max_jitter_factor: Option<f64>,
            }
            impl ::core::fmt::Debug for RetryPolicy {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("RetryPolicy")
                        .field("max-attempts", &self.max_attempts)
                        .field("min-delay", &self.min_delay)
                        .field("max-delay", &self.max_delay)
                        .field("multiplier", &self.multiplier)
                        .field("max-jitter-factor", &self.max_jitter_factor)
                        .finish()
                }
            }
            /// Configurable persistence level for workers
            #[derive(Clone, Copy)]
            pub enum PersistenceLevel {
                PersistNothing,
                PersistRemoteSideEffects,
                Smart,
            }
            impl ::core::fmt::Debug for PersistenceLevel {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        PersistenceLevel::PersistNothing => {
                            f.debug_tuple("PersistenceLevel::PersistNothing").finish()
                        }
                        PersistenceLevel::PersistRemoteSideEffects => {
                            f.debug_tuple("PersistenceLevel::PersistRemoteSideEffects")
                                .finish()
                        }
                        PersistenceLevel::Smart => {
                            f.debug_tuple("PersistenceLevel::Smart").finish()
                        }
                    }
                }
            }
            /// Describes how to update a worker to a different component version
            #[repr(u8)]
            #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
            pub enum UpdateMode {
                /// Automatic update tries to recover the worker using the new component version
                /// and may fail if there is a divergence.
                Automatic,
                /// Manual, snapshot-based update uses a user-defined implementation of the `save-snapshot` interface
                /// to store the worker's state, and a user-defined implementation of the `load-snapshot` interface to
                /// load it into the new version.
                SnapshotBased,
            }
            impl ::core::fmt::Debug for UpdateMode {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        UpdateMode::Automatic => {
                            f.debug_tuple("UpdateMode::Automatic").finish()
                        }
                        UpdateMode::SnapshotBased => {
                            f.debug_tuple("UpdateMode::SnapshotBased").finish()
                        }
                    }
                }
            }
            impl UpdateMode {
                #[doc(hidden)]
                pub unsafe fn _lift(val: u8) -> UpdateMode {
                    if !cfg!(debug_assertions) {
                        return ::core::mem::transmute(val);
                    }
                    match val {
                        0 => UpdateMode::Automatic,
                        1 => UpdateMode::SnapshotBased,
                        _ => panic!("invalid enum discriminant"),
                    }
                }
            }
            #[repr(u8)]
            #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
            pub enum FilterComparator {
                Equal,
                NotEqual,
                GreaterEqual,
                Greater,
                LessEqual,
                Less,
            }
            impl ::core::fmt::Debug for FilterComparator {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        FilterComparator::Equal => {
                            f.debug_tuple("FilterComparator::Equal").finish()
                        }
                        FilterComparator::NotEqual => {
                            f.debug_tuple("FilterComparator::NotEqual").finish()
                        }
                        FilterComparator::GreaterEqual => {
                            f.debug_tuple("FilterComparator::GreaterEqual").finish()
                        }
                        FilterComparator::Greater => {
                            f.debug_tuple("FilterComparator::Greater").finish()
                        }
                        FilterComparator::LessEqual => {
                            f.debug_tuple("FilterComparator::LessEqual").finish()
                        }
                        FilterComparator::Less => {
                            f.debug_tuple("FilterComparator::Less").finish()
                        }
                    }
                }
            }
            impl FilterComparator {
                #[doc(hidden)]
                pub unsafe fn _lift(val: u8) -> FilterComparator {
                    if !cfg!(debug_assertions) {
                        return ::core::mem::transmute(val);
                    }
                    match val {
                        0 => FilterComparator::Equal,
                        1 => FilterComparator::NotEqual,
                        2 => FilterComparator::GreaterEqual,
                        3 => FilterComparator::Greater,
                        4 => FilterComparator::LessEqual,
                        5 => FilterComparator::Less,
                        _ => panic!("invalid enum discriminant"),
                    }
                }
            }
            #[repr(u8)]
            #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
            pub enum StringFilterComparator {
                Equal,
                NotEqual,
                Like,
                NotLike,
            }
            impl ::core::fmt::Debug for StringFilterComparator {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        StringFilterComparator::Equal => {
                            f.debug_tuple("StringFilterComparator::Equal").finish()
                        }
                        StringFilterComparator::NotEqual => {
                            f.debug_tuple("StringFilterComparator::NotEqual").finish()
                        }
                        StringFilterComparator::Like => {
                            f.debug_tuple("StringFilterComparator::Like").finish()
                        }
                        StringFilterComparator::NotLike => {
                            f.debug_tuple("StringFilterComparator::NotLike").finish()
                        }
                    }
                }
            }
            impl StringFilterComparator {
                #[doc(hidden)]
                pub unsafe fn _lift(val: u8) -> StringFilterComparator {
                    if !cfg!(debug_assertions) {
                        return ::core::mem::transmute(val);
                    }
                    match val {
                        0 => StringFilterComparator::Equal,
                        1 => StringFilterComparator::NotEqual,
                        2 => StringFilterComparator::Like,
                        3 => StringFilterComparator::NotLike,
                        _ => panic!("invalid enum discriminant"),
                    }
                }
            }
            #[repr(u8)]
            #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
            pub enum WorkerStatus {
                /// The worker is running an invoked function
                Running,
                /// The worker is ready to run an invoked function
                Idle,
                /// An invocation is active but waiting for something (sleeping, waiting for a promise)
                Suspended,
                /// The last invocation was interrupted but will be resumed
                Interrupted,
                /// The last invocation failed and a retry was scheduled
                Retrying,
                /// The last invocation failed and the worker can no longer be used
                Failed,
                /// The worker exited after a successful invocation and can no longer be invoked
                Exited,
            }
            impl ::core::fmt::Debug for WorkerStatus {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        WorkerStatus::Running => {
                            f.debug_tuple("WorkerStatus::Running").finish()
                        }
                        WorkerStatus::Idle => {
                            f.debug_tuple("WorkerStatus::Idle").finish()
                        }
                        WorkerStatus::Suspended => {
                            f.debug_tuple("WorkerStatus::Suspended").finish()
                        }
                        WorkerStatus::Interrupted => {
                            f.debug_tuple("WorkerStatus::Interrupted").finish()
                        }
                        WorkerStatus::Retrying => {
                            f.debug_tuple("WorkerStatus::Retrying").finish()
                        }
                        WorkerStatus::Failed => {
                            f.debug_tuple("WorkerStatus::Failed").finish()
                        }
                        WorkerStatus::Exited => {
                            f.debug_tuple("WorkerStatus::Exited").finish()
                        }
                    }
                }
            }
            impl WorkerStatus {
                #[doc(hidden)]
                pub unsafe fn _lift(val: u8) -> WorkerStatus {
                    if !cfg!(debug_assertions) {
                        return ::core::mem::transmute(val);
                    }
                    match val {
                        0 => WorkerStatus::Running,
                        1 => WorkerStatus::Idle,
                        2 => WorkerStatus::Suspended,
                        3 => WorkerStatus::Interrupted,
                        4 => WorkerStatus::Retrying,
                        5 => WorkerStatus::Failed,
                        6 => WorkerStatus::Exited,
                        _ => panic!("invalid enum discriminant"),
                    }
                }
            }
            #[derive(Clone)]
            pub struct WorkerNameFilter {
                pub comparator: StringFilterComparator,
                pub value: _rt::String,
            }
            impl ::core::fmt::Debug for WorkerNameFilter {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("WorkerNameFilter")
                        .field("comparator", &self.comparator)
                        .field("value", &self.value)
                        .finish()
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct WorkerStatusFilter {
                pub comparator: FilterComparator,
                pub value: WorkerStatus,
            }
            impl ::core::fmt::Debug for WorkerStatusFilter {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("WorkerStatusFilter")
                        .field("comparator", &self.comparator)
                        .field("value", &self.value)
                        .finish()
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct WorkerVersionFilter {
                pub comparator: FilterComparator,
                pub value: u64,
            }
            impl ::core::fmt::Debug for WorkerVersionFilter {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("WorkerVersionFilter")
                        .field("comparator", &self.comparator)
                        .field("value", &self.value)
                        .finish()
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct WorkerCreatedAtFilter {
                pub comparator: FilterComparator,
                pub value: u64,
            }
            impl ::core::fmt::Debug for WorkerCreatedAtFilter {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("WorkerCreatedAtFilter")
                        .field("comparator", &self.comparator)
                        .field("value", &self.value)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub struct WorkerEnvFilter {
                pub name: _rt::String,
                pub comparator: StringFilterComparator,
                pub value: _rt::String,
            }
            impl ::core::fmt::Debug for WorkerEnvFilter {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("WorkerEnvFilter")
                        .field("name", &self.name)
                        .field("comparator", &self.comparator)
                        .field("value", &self.value)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub enum WorkerPropertyFilter {
                Name(WorkerNameFilter),
                Status(WorkerStatusFilter),
                Version(WorkerVersionFilter),
                CreatedAt(WorkerCreatedAtFilter),
                Env(WorkerEnvFilter),
            }
            impl ::core::fmt::Debug for WorkerPropertyFilter {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        WorkerPropertyFilter::Name(e) => {
                            f.debug_tuple("WorkerPropertyFilter::Name").field(e).finish()
                        }
                        WorkerPropertyFilter::Status(e) => {
                            f.debug_tuple("WorkerPropertyFilter::Status")
                                .field(e)
                                .finish()
                        }
                        WorkerPropertyFilter::Version(e) => {
                            f.debug_tuple("WorkerPropertyFilter::Version")
                                .field(e)
                                .finish()
                        }
                        WorkerPropertyFilter::CreatedAt(e) => {
                            f.debug_tuple("WorkerPropertyFilter::CreatedAt")
                                .field(e)
                                .finish()
                        }
                        WorkerPropertyFilter::Env(e) => {
                            f.debug_tuple("WorkerPropertyFilter::Env").field(e).finish()
                        }
                    }
                }
            }
            #[derive(Clone)]
            pub struct WorkerAllFilter {
                pub filters: _rt::Vec<WorkerPropertyFilter>,
            }
            impl ::core::fmt::Debug for WorkerAllFilter {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("WorkerAllFilter")
                        .field("filters", &self.filters)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub struct WorkerAnyFilter {
                pub filters: _rt::Vec<WorkerAllFilter>,
            }
            impl ::core::fmt::Debug for WorkerAnyFilter {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("WorkerAnyFilter")
                        .field("filters", &self.filters)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub struct WorkerMetadata {
                pub worker_id: WorkerId,
                pub args: _rt::Vec<_rt::String>,
                pub env: _rt::Vec<(_rt::String, _rt::String)>,
                pub status: WorkerStatus,
                pub component_version: u64,
                pub retry_count: u64,
            }
            impl ::core::fmt::Debug for WorkerMetadata {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("WorkerMetadata")
                        .field("worker-id", &self.worker_id)
                        .field("args", &self.args)
                        .field("env", &self.env)
                        .field("status", &self.status)
                        .field("component-version", &self.component_version)
                        .field("retry-count", &self.retry_count)
                        .finish()
                }
            }
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct GetWorkers {
                handle: _rt::Resource<GetWorkers>,
            }
            impl GetWorkers {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 GetWorkers {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "golem:api/host@1.1.5")]
                        extern "C" {
                            #[link_name = "[resource-drop]get-workers"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            /// Target parameter for the `revert-worker` operation
            #[derive(Clone, Copy)]
            pub enum RevertWorkerTarget {
                /// Revert to a specific oplog index. The given index will be the last one to be kept.
                RevertToOplogIndex(OplogIndex),
                /// Revert the last N invocations.
                RevertLastInvocations(u64),
            }
            impl ::core::fmt::Debug for RevertWorkerTarget {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        RevertWorkerTarget::RevertToOplogIndex(e) => {
                            f.debug_tuple("RevertWorkerTarget::RevertToOplogIndex")
                                .field(e)
                                .finish()
                        }
                        RevertWorkerTarget::RevertLastInvocations(e) => {
                            f.debug_tuple("RevertWorkerTarget::RevertLastInvocations")
                                .field(e)
                                .finish()
                        }
                    }
                }
            }
            impl GetWorkers {
                #[allow(unused_unsafe, clippy::all)]
                pub fn new(
                    component_id: ComponentId,
                    filter: Option<&WorkerAnyFilter>,
                    precise: bool,
                ) -> Self {
                    unsafe {
                        let mut cleanup_list = _rt::Vec::new();
                        let ComponentId { uuid: uuid0 } = component_id;
                        let Uuid { high_bits: high_bits1, low_bits: low_bits1 } = uuid0;
                        let (result14_0, result14_1, result14_2) = match filter {
                            Some(e) => {
                                let WorkerAnyFilter { filters: filters2 } = e;
                                let vec13 = filters2;
                                let len13 = vec13.len();
                                let layout13 = _rt::alloc::Layout::from_size_align_unchecked(
                                    vec13.len() * 8,
                                    4,
                                );
                                let result13 = if layout13.size() != 0 {
                                    let ptr = _rt::alloc::alloc(layout13).cast::<u8>();
                                    if ptr.is_null() {
                                        _rt::alloc::handle_alloc_error(layout13);
                                    }
                                    ptr
                                } else {
                                    ::core::ptr::null_mut()
                                };
                                for (i, e) in vec13.into_iter().enumerate() {
                                    let base = result13.add(i * 8);
                                    {
                                        let WorkerAllFilter { filters: filters3 } = e;
                                        let vec12 = filters3;
                                        let len12 = vec12.len();
                                        let layout12 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec12.len() * 32,
                                            8,
                                        );
                                        let result12 = if layout12.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout12).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout12);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec12.into_iter().enumerate() {
                                            let base = result12.add(i * 32);
                                            {
                                                match e {
                                                    WorkerPropertyFilter::Name(e) => {
                                                        *base.add(0).cast::<u8>() = (0i32) as u8;
                                                        let WorkerNameFilter {
                                                            comparator: comparator4,
                                                            value: value4,
                                                        } = e;
                                                        *base.add(8).cast::<u8>() = (comparator4.clone() as i32)
                                                            as u8;
                                                        let vec5 = value4;
                                                        let ptr5 = vec5.as_ptr().cast::<u8>();
                                                        let len5 = vec5.len();
                                                        *base.add(16).cast::<usize>() = len5;
                                                        *base.add(12).cast::<*mut u8>() = ptr5.cast_mut();
                                                    }
                                                    WorkerPropertyFilter::Status(e) => {
                                                        *base.add(0).cast::<u8>() = (1i32) as u8;
                                                        let WorkerStatusFilter {
                                                            comparator: comparator6,
                                                            value: value6,
                                                        } = e;
                                                        *base.add(8).cast::<u8>() = (comparator6.clone() as i32)
                                                            as u8;
                                                        *base.add(9).cast::<u8>() = (value6.clone() as i32) as u8;
                                                    }
                                                    WorkerPropertyFilter::Version(e) => {
                                                        *base.add(0).cast::<u8>() = (2i32) as u8;
                                                        let WorkerVersionFilter {
                                                            comparator: comparator7,
                                                            value: value7,
                                                        } = e;
                                                        *base.add(8).cast::<u8>() = (comparator7.clone() as i32)
                                                            as u8;
                                                        *base.add(16).cast::<i64>() = _rt::as_i64(value7);
                                                    }
                                                    WorkerPropertyFilter::CreatedAt(e) => {
                                                        *base.add(0).cast::<u8>() = (3i32) as u8;
                                                        let WorkerCreatedAtFilter {
                                                            comparator: comparator8,
                                                            value: value8,
                                                        } = e;
                                                        *base.add(8).cast::<u8>() = (comparator8.clone() as i32)
                                                            as u8;
                                                        *base.add(16).cast::<i64>() = _rt::as_i64(value8);
                                                    }
                                                    WorkerPropertyFilter::Env(e) => {
                                                        *base.add(0).cast::<u8>() = (4i32) as u8;
                                                        let WorkerEnvFilter {
                                                            name: name9,
                                                            comparator: comparator9,
                                                            value: value9,
                                                        } = e;
                                                        let vec10 = name9;
                                                        let ptr10 = vec10.as_ptr().cast::<u8>();
                                                        let len10 = vec10.len();
                                                        *base.add(12).cast::<usize>() = len10;
                                                        *base.add(8).cast::<*mut u8>() = ptr10.cast_mut();
                                                        *base.add(16).cast::<u8>() = (comparator9.clone() as i32)
                                                            as u8;
                                                        let vec11 = value9;
                                                        let ptr11 = vec11.as_ptr().cast::<u8>();
                                                        let len11 = vec11.len();
                                                        *base.add(24).cast::<usize>() = len11;
                                                        *base.add(20).cast::<*mut u8>() = ptr11.cast_mut();
                                                    }
                                                }
                                            }
                                        }
                                        *base.add(4).cast::<usize>() = len12;
                                        *base.add(0).cast::<*mut u8>() = result12;
                                        cleanup_list.extend_from_slice(&[(result12, layout12)]);
                                    }
                                }
                                cleanup_list.extend_from_slice(&[(result13, layout13)]);
                                (1i32, result13, len13)
                            }
                            None => (0i32, ::core::ptr::null_mut(), 0usize),
                        };
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:api/host@1.1.5")]
                        extern "C" {
                            #[link_name = "[constructor]get-workers"]
                            fn wit_import(
                                _: i64,
                                _: i64,
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: i32,
                            ) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i64,
                            _: i64,
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: i32,
                        ) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import(
                            _rt::as_i64(high_bits1),
                            _rt::as_i64(low_bits1),
                            result14_0,
                            result14_1,
                            result14_2,
                            match &precise {
                                true => 1,
                                false => 0,
                            },
                        );
                        for (ptr, layout) in cleanup_list {
                            if layout.size() != 0 {
                                _rt::alloc::dealloc(ptr.cast(), layout);
                            }
                        }
                        GetWorkers::from_handle(ret as u32)
                    }
                }
            }
            impl GetWorkers {
                #[allow(unused_unsafe, clippy::all)]
                pub fn get_next(&self) -> Option<_rt::Vec<WorkerMetadata>> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:api/host@1.1.5")]
                        extern "C" {
                            #[link_name = "[method]get-workers.get-next"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<*mut u8>();
                                    let l3 = *ptr0.add(8).cast::<usize>();
                                    let base27 = l2;
                                    let len27 = l3;
                                    let mut result27 = _rt::Vec::with_capacity(len27);
                                    for i in 0..len27 {
                                        let base = base27.add(i * 64);
                                        let e27 = {
                                            let l4 = *base.add(0).cast::<i64>();
                                            let l5 = *base.add(8).cast::<i64>();
                                            let l6 = *base.add(16).cast::<*mut u8>();
                                            let l7 = *base.add(20).cast::<usize>();
                                            let len8 = l7;
                                            let bytes8 = _rt::Vec::from_raw_parts(
                                                l6.cast(),
                                                len8,
                                                len8,
                                            );
                                            let l9 = *base.add(24).cast::<*mut u8>();
                                            let l10 = *base.add(28).cast::<usize>();
                                            let base14 = l9;
                                            let len14 = l10;
                                            let mut result14 = _rt::Vec::with_capacity(len14);
                                            for i in 0..len14 {
                                                let base = base14.add(i * 8);
                                                let e14 = {
                                                    let l11 = *base.add(0).cast::<*mut u8>();
                                                    let l12 = *base.add(4).cast::<usize>();
                                                    let len13 = l12;
                                                    let bytes13 = _rt::Vec::from_raw_parts(
                                                        l11.cast(),
                                                        len13,
                                                        len13,
                                                    );
                                                    _rt::string_lift(bytes13)
                                                };
                                                result14.push(e14);
                                            }
                                            _rt::cabi_dealloc(base14, len14 * 8, 4);
                                            let l15 = *base.add(32).cast::<*mut u8>();
                                            let l16 = *base.add(36).cast::<usize>();
                                            let base23 = l15;
                                            let len23 = l16;
                                            let mut result23 = _rt::Vec::with_capacity(len23);
                                            for i in 0..len23 {
                                                let base = base23.add(i * 16);
                                                let e23 = {
                                                    let l17 = *base.add(0).cast::<*mut u8>();
                                                    let l18 = *base.add(4).cast::<usize>();
                                                    let len19 = l18;
                                                    let bytes19 = _rt::Vec::from_raw_parts(
                                                        l17.cast(),
                                                        len19,
                                                        len19,
                                                    );
                                                    let l20 = *base.add(8).cast::<*mut u8>();
                                                    let l21 = *base.add(12).cast::<usize>();
                                                    let len22 = l21;
                                                    let bytes22 = _rt::Vec::from_raw_parts(
                                                        l20.cast(),
                                                        len22,
                                                        len22,
                                                    );
                                                    (_rt::string_lift(bytes19), _rt::string_lift(bytes22))
                                                };
                                                result23.push(e23);
                                            }
                                            _rt::cabi_dealloc(base23, len23 * 16, 4);
                                            let l24 = i32::from(*base.add(40).cast::<u8>());
                                            let l25 = *base.add(48).cast::<i64>();
                                            let l26 = *base.add(56).cast::<i64>();
                                            WorkerMetadata {
                                                worker_id: WorkerId {
                                                    component_id: ComponentId {
                                                        uuid: Uuid {
                                                            high_bits: l4 as u64,
                                                            low_bits: l5 as u64,
                                                        },
                                                    },
                                                    worker_name: _rt::string_lift(bytes8),
                                                },
                                                args: result14,
                                                env: result23,
                                                status: WorkerStatus::_lift(l24 as u8),
                                                component_version: l25 as u64,
                                                retry_count: l26 as u64,
                                            }
                                        };
                                        result27.push(e27);
                                    }
                                    _rt::cabi_dealloc(base27, len27 * 64, 8);
                                    result27
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Create a new promise
            pub fn create_promise() -> PromiseId {
                unsafe {
                    #[repr(align(8))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 32]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 32]);
                    let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "create-promise"]
                        fn wit_import(_: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: *mut u8) {
                        unreachable!()
                    }
                    wit_import(ptr0);
                    let l1 = *ptr0.add(0).cast::<i64>();
                    let l2 = *ptr0.add(8).cast::<i64>();
                    let l3 = *ptr0.add(16).cast::<*mut u8>();
                    let l4 = *ptr0.add(20).cast::<usize>();
                    let len5 = l4;
                    let bytes5 = _rt::Vec::from_raw_parts(l3.cast(), len5, len5);
                    let l6 = *ptr0.add(24).cast::<i64>();
                    PromiseId {
                        worker_id: WorkerId {
                            component_id: ComponentId {
                                uuid: Uuid {
                                    high_bits: l1 as u64,
                                    low_bits: l2 as u64,
                                },
                            },
                            worker_name: _rt::string_lift(bytes5),
                        },
                        oplog_idx: l6 as u64,
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Suspends execution until the given promise gets completed, and returns the payload passed to
            /// the promise completion.
            pub fn await_promise(promise_id: &PromiseId) -> _rt::Vec<u8> {
                unsafe {
                    #[repr(align(4))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]);
                    let PromiseId { worker_id: worker_id0, oplog_idx: oplog_idx0 } = promise_id;
                    let WorkerId {
                        component_id: component_id1,
                        worker_name: worker_name1,
                    } = worker_id0;
                    let ComponentId { uuid: uuid2 } = component_id1;
                    let Uuid { high_bits: high_bits3, low_bits: low_bits3 } = uuid2;
                    let vec4 = worker_name1;
                    let ptr4 = vec4.as_ptr().cast::<u8>();
                    let len4 = vec4.len();
                    let ptr5 = ret_area.0.as_mut_ptr().cast::<u8>();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "await-promise"]
                        fn wit_import(
                            _: i64,
                            _: i64,
                            _: *mut u8,
                            _: usize,
                            _: i64,
                            _: *mut u8,
                        );
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(
                        _: i64,
                        _: i64,
                        _: *mut u8,
                        _: usize,
                        _: i64,
                        _: *mut u8,
                    ) {
                        unreachable!()
                    }
                    wit_import(
                        _rt::as_i64(high_bits3),
                        _rt::as_i64(low_bits3),
                        ptr4.cast_mut(),
                        len4,
                        _rt::as_i64(oplog_idx0),
                        ptr5,
                    );
                    let l6 = *ptr5.add(0).cast::<*mut u8>();
                    let l7 = *ptr5.add(4).cast::<usize>();
                    let len8 = l7;
                    _rt::Vec::from_raw_parts(l6.cast(), len8, len8)
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Checks whether the given promise is completed. If not, it returns None. If the promise is completed,
            /// it returns the payload passed to the promise completion.
            pub fn poll_promise(promise_id: &PromiseId) -> Option<_rt::Vec<u8>> {
                unsafe {
                    #[repr(align(4))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]);
                    let PromiseId { worker_id: worker_id0, oplog_idx: oplog_idx0 } = promise_id;
                    let WorkerId {
                        component_id: component_id1,
                        worker_name: worker_name1,
                    } = worker_id0;
                    let ComponentId { uuid: uuid2 } = component_id1;
                    let Uuid { high_bits: high_bits3, low_bits: low_bits3 } = uuid2;
                    let vec4 = worker_name1;
                    let ptr4 = vec4.as_ptr().cast::<u8>();
                    let len4 = vec4.len();
                    let ptr5 = ret_area.0.as_mut_ptr().cast::<u8>();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "poll-promise"]
                        fn wit_import(
                            _: i64,
                            _: i64,
                            _: *mut u8,
                            _: usize,
                            _: i64,
                            _: *mut u8,
                        );
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(
                        _: i64,
                        _: i64,
                        _: *mut u8,
                        _: usize,
                        _: i64,
                        _: *mut u8,
                    ) {
                        unreachable!()
                    }
                    wit_import(
                        _rt::as_i64(high_bits3),
                        _rt::as_i64(low_bits3),
                        ptr4.cast_mut(),
                        len4,
                        _rt::as_i64(oplog_idx0),
                        ptr5,
                    );
                    let l6 = i32::from(*ptr5.add(0).cast::<u8>());
                    match l6 {
                        0 => None,
                        1 => {
                            let e = {
                                let l7 = *ptr5.add(4).cast::<*mut u8>();
                                let l8 = *ptr5.add(8).cast::<usize>();
                                let len9 = l8;
                                _rt::Vec::from_raw_parts(l7.cast(), len9, len9)
                            };
                            Some(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Completes the given promise with the given payload. Returns true if the promise was completed, false
            /// if the promise was already completed. The payload is passed to the worker that is awaiting the promise.
            pub fn complete_promise(promise_id: &PromiseId, data: &[u8]) -> bool {
                unsafe {
                    let PromiseId { worker_id: worker_id0, oplog_idx: oplog_idx0 } = promise_id;
                    let WorkerId {
                        component_id: component_id1,
                        worker_name: worker_name1,
                    } = worker_id0;
                    let ComponentId { uuid: uuid2 } = component_id1;
                    let Uuid { high_bits: high_bits3, low_bits: low_bits3 } = uuid2;
                    let vec4 = worker_name1;
                    let ptr4 = vec4.as_ptr().cast::<u8>();
                    let len4 = vec4.len();
                    let vec5 = data;
                    let ptr5 = vec5.as_ptr().cast::<u8>();
                    let len5 = vec5.len();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "complete-promise"]
                        fn wit_import(
                            _: i64,
                            _: i64,
                            _: *mut u8,
                            _: usize,
                            _: i64,
                            _: *mut u8,
                            _: usize,
                        ) -> i32;
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(
                        _: i64,
                        _: i64,
                        _: *mut u8,
                        _: usize,
                        _: i64,
                        _: *mut u8,
                        _: usize,
                    ) -> i32 {
                        unreachable!()
                    }
                    let ret = wit_import(
                        _rt::as_i64(high_bits3),
                        _rt::as_i64(low_bits3),
                        ptr4.cast_mut(),
                        len4,
                        _rt::as_i64(oplog_idx0),
                        ptr5.cast_mut(),
                        len5,
                    );
                    _rt::bool_lift(ret as u8)
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Deletes the given promise
            pub fn delete_promise(promise_id: &PromiseId) {
                unsafe {
                    let PromiseId { worker_id: worker_id0, oplog_idx: oplog_idx0 } = promise_id;
                    let WorkerId {
                        component_id: component_id1,
                        worker_name: worker_name1,
                    } = worker_id0;
                    let ComponentId { uuid: uuid2 } = component_id1;
                    let Uuid { high_bits: high_bits3, low_bits: low_bits3 } = uuid2;
                    let vec4 = worker_name1;
                    let ptr4 = vec4.as_ptr().cast::<u8>();
                    let len4 = vec4.len();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "delete-promise"]
                        fn wit_import(_: i64, _: i64, _: *mut u8, _: usize, _: i64);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i64, _: i64, _: *mut u8, _: usize, _: i64) {
                        unreachable!()
                    }
                    wit_import(
                        _rt::as_i64(high_bits3),
                        _rt::as_i64(low_bits3),
                        ptr4.cast_mut(),
                        len4,
                        _rt::as_i64(oplog_idx0),
                    );
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Returns the current position in the persistent op log
            pub fn get_oplog_index() -> OplogIndex {
                unsafe {
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "get-oplog-index"]
                        fn wit_import() -> i64;
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import() -> i64 {
                        unreachable!()
                    }
                    let ret = wit_import();
                    ret as u64
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Makes the current worker travel back in time and continue execution from the given position in the persistent
            /// op log.
            pub fn set_oplog_index(oplog_idx: OplogIndex) {
                unsafe {
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "set-oplog-index"]
                        fn wit_import(_: i64);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i64) {
                        unreachable!()
                    }
                    wit_import(_rt::as_i64(oplog_idx));
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Blocks the execution until the oplog has been written to at least the specified number of replicas,
            /// or the maximum number of replicas if the requested number is higher.
            pub fn oplog_commit(replicas: u8) {
                unsafe {
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "oplog-commit"]
                        fn wit_import(_: i32);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i32) {
                        unreachable!()
                    }
                    wit_import(_rt::as_i32(&replicas));
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Marks the beginning of an atomic operation.
            /// In case of a failure within the region selected by `mark-begin-operation` and `mark-end-operation`
            /// the whole region will be reexecuted on retry.
            /// The end of the region is when `mark-end-operation` is called with the returned oplog-index.
            pub fn mark_begin_operation() -> OplogIndex {
                unsafe {
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "mark-begin-operation"]
                        fn wit_import() -> i64;
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import() -> i64 {
                        unreachable!()
                    }
                    let ret = wit_import();
                    ret as u64
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Commits this atomic operation. After `mark-end-operation` is called for a given index, further calls
            /// with the same parameter will do nothing.
            pub fn mark_end_operation(begin: OplogIndex) {
                unsafe {
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "mark-end-operation"]
                        fn wit_import(_: i64);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i64) {
                        unreachable!()
                    }
                    wit_import(_rt::as_i64(begin));
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Gets the current retry policy associated with the worker
            pub fn get_retry_policy() -> RetryPolicy {
                unsafe {
                    #[repr(align(8))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 48]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 48]);
                    let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "get-retry-policy"]
                        fn wit_import(_: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: *mut u8) {
                        unreachable!()
                    }
                    wit_import(ptr0);
                    let l1 = *ptr0.add(0).cast::<i32>();
                    let l2 = *ptr0.add(8).cast::<i64>();
                    let l3 = *ptr0.add(16).cast::<i64>();
                    let l4 = *ptr0.add(24).cast::<f64>();
                    let l5 = i32::from(*ptr0.add(32).cast::<u8>());
                    RetryPolicy {
                        max_attempts: l1 as u32,
                        min_delay: l2 as u64,
                        max_delay: l3 as u64,
                        multiplier: l4,
                        max_jitter_factor: match l5 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l6 = *ptr0.add(40).cast::<f64>();
                                    l6
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        },
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Overrides the current retry policy associated with the worker. Following this call, `get-retry-policy` will return the
            /// new retry policy.
            pub fn set_retry_policy(new_retry_policy: RetryPolicy) {
                unsafe {
                    let RetryPolicy {
                        max_attempts: max_attempts0,
                        min_delay: min_delay0,
                        max_delay: max_delay0,
                        multiplier: multiplier0,
                        max_jitter_factor: max_jitter_factor0,
                    } = new_retry_policy;
                    let (result1_0, result1_1) = match max_jitter_factor0 {
                        Some(e) => (1i32, _rt::as_f64(e)),
                        None => (0i32, 0.0f64),
                    };
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "set-retry-policy"]
                        fn wit_import(_: i32, _: i64, _: i64, _: f64, _: i32, _: f64);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i32, _: i64, _: i64, _: f64, _: i32, _: f64) {
                        unreachable!()
                    }
                    wit_import(
                        _rt::as_i32(max_attempts0),
                        _rt::as_i64(min_delay0),
                        _rt::as_i64(max_delay0),
                        _rt::as_f64(multiplier0),
                        result1_0,
                        result1_1,
                    );
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Gets the worker's current persistence level.
            pub fn get_oplog_persistence_level() -> PersistenceLevel {
                unsafe {
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "get-oplog-persistence-level"]
                        fn wit_import() -> i32;
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import() -> i32 {
                        unreachable!()
                    }
                    let ret = wit_import();
                    let v0 = match ret {
                        0 => PersistenceLevel::PersistNothing,
                        1 => PersistenceLevel::PersistRemoteSideEffects,
                        n => {
                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                            PersistenceLevel::Smart
                        }
                    };
                    v0
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Sets the worker's current persistence level. This can increase the performance of execution in cases where durable
            /// execution is not required.
            pub fn set_oplog_persistence_level(new_persistence_level: PersistenceLevel) {
                unsafe {
                    let result0 = match new_persistence_level {
                        PersistenceLevel::PersistNothing => 0i32,
                        PersistenceLevel::PersistRemoteSideEffects => 1i32,
                        PersistenceLevel::Smart => 2i32,
                    };
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "set-oplog-persistence-level"]
                        fn wit_import(_: i32);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i32) {
                        unreachable!()
                    }
                    wit_import(result0);
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Gets the current idempotence mode. See `set-idempotence-mode` for details.
            pub fn get_idempotence_mode() -> bool {
                unsafe {
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "get-idempotence-mode"]
                        fn wit_import() -> i32;
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import() -> i32 {
                        unreachable!()
                    }
                    let ret = wit_import();
                    _rt::bool_lift(ret as u8)
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Sets the current idempotence mode. The default is true.
            /// True means side-effects are treated idempotent and Golem guarantees at-least-once semantics.
            /// In case of false the executor provides at-most-once semantics, failing the worker in case it is
            /// not known if the side effect was already executed.
            pub fn set_idempotence_mode(idempotent: bool) {
                unsafe {
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "set-idempotence-mode"]
                        fn wit_import(_: i32);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i32) {
                        unreachable!()
                    }
                    wit_import(
                        match &idempotent {
                            true => 1,
                            false => 0,
                        },
                    );
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Generates an idempotency key. This operation will never be replayed —
            /// i.e. not only is this key generated, but it is persisted and committed, such that the key can be used in third-party systems (e.g. payment processing)
            /// to introduce idempotence.
            pub fn generate_idempotency_key() -> Uuid {
                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 = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "generate-idempotency-key"]
                        fn wit_import(_: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: *mut u8) {
                        unreachable!()
                    }
                    wit_import(ptr0);
                    let l1 = *ptr0.add(0).cast::<i64>();
                    let l2 = *ptr0.add(8).cast::<i64>();
                    Uuid {
                        high_bits: l1 as u64,
                        low_bits: l2 as u64,
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Initiates an update attempt for the given worker. The function returns immediately once the request has been processed,
            /// not waiting for the worker to get updated.
            pub fn update_worker(
                worker_id: &WorkerId,
                target_version: ComponentVersion,
                mode: UpdateMode,
            ) {
                unsafe {
                    let WorkerId {
                        component_id: component_id0,
                        worker_name: worker_name0,
                    } = worker_id;
                    let ComponentId { uuid: uuid1 } = component_id0;
                    let Uuid { high_bits: high_bits2, low_bits: low_bits2 } = uuid1;
                    let vec3 = worker_name0;
                    let ptr3 = vec3.as_ptr().cast::<u8>();
                    let len3 = vec3.len();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "update-worker"]
                        fn wit_import(
                            _: i64,
                            _: i64,
                            _: *mut u8,
                            _: usize,
                            _: i64,
                            _: i32,
                        );
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i64, _: i64, _: *mut u8, _: usize, _: i64, _: i32) {
                        unreachable!()
                    }
                    wit_import(
                        _rt::as_i64(high_bits2),
                        _rt::as_i64(low_bits2),
                        ptr3.cast_mut(),
                        len3,
                        _rt::as_i64(target_version),
                        mode.clone() as i32,
                    );
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Get current worker metadata
            pub fn get_self_metadata() -> WorkerMetadata {
                unsafe {
                    #[repr(align(8))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 64]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 64]);
                    let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "get-self-metadata"]
                        fn wit_import(_: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: *mut u8) {
                        unreachable!()
                    }
                    wit_import(ptr0);
                    let l1 = *ptr0.add(0).cast::<i64>();
                    let l2 = *ptr0.add(8).cast::<i64>();
                    let l3 = *ptr0.add(16).cast::<*mut u8>();
                    let l4 = *ptr0.add(20).cast::<usize>();
                    let len5 = l4;
                    let bytes5 = _rt::Vec::from_raw_parts(l3.cast(), len5, len5);
                    let l6 = *ptr0.add(24).cast::<*mut u8>();
                    let l7 = *ptr0.add(28).cast::<usize>();
                    let base11 = l6;
                    let len11 = l7;
                    let mut result11 = _rt::Vec::with_capacity(len11);
                    for i in 0..len11 {
                        let base = base11.add(i * 8);
                        let e11 = {
                            let l8 = *base.add(0).cast::<*mut u8>();
                            let l9 = *base.add(4).cast::<usize>();
                            let len10 = l9;
                            let bytes10 = _rt::Vec::from_raw_parts(
                                l8.cast(),
                                len10,
                                len10,
                            );
                            _rt::string_lift(bytes10)
                        };
                        result11.push(e11);
                    }
                    _rt::cabi_dealloc(base11, len11 * 8, 4);
                    let l12 = *ptr0.add(32).cast::<*mut u8>();
                    let l13 = *ptr0.add(36).cast::<usize>();
                    let base20 = l12;
                    let len20 = l13;
                    let mut result20 = _rt::Vec::with_capacity(len20);
                    for i in 0..len20 {
                        let base = base20.add(i * 16);
                        let e20 = {
                            let l14 = *base.add(0).cast::<*mut u8>();
                            let l15 = *base.add(4).cast::<usize>();
                            let len16 = l15;
                            let bytes16 = _rt::Vec::from_raw_parts(
                                l14.cast(),
                                len16,
                                len16,
                            );
                            let l17 = *base.add(8).cast::<*mut u8>();
                            let l18 = *base.add(12).cast::<usize>();
                            let len19 = l18;
                            let bytes19 = _rt::Vec::from_raw_parts(
                                l17.cast(),
                                len19,
                                len19,
                            );
                            (_rt::string_lift(bytes16), _rt::string_lift(bytes19))
                        };
                        result20.push(e20);
                    }
                    _rt::cabi_dealloc(base20, len20 * 16, 4);
                    let l21 = i32::from(*ptr0.add(40).cast::<u8>());
                    let l22 = *ptr0.add(48).cast::<i64>();
                    let l23 = *ptr0.add(56).cast::<i64>();
                    WorkerMetadata {
                        worker_id: WorkerId {
                            component_id: ComponentId {
                                uuid: Uuid {
                                    high_bits: l1 as u64,
                                    low_bits: l2 as u64,
                                },
                            },
                            worker_name: _rt::string_lift(bytes5),
                        },
                        args: result11,
                        env: result20,
                        status: WorkerStatus::_lift(l21 as u8),
                        component_version: l22 as u64,
                        retry_count: l23 as u64,
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Get worker metadata
            pub fn get_worker_metadata(worker_id: &WorkerId) -> Option<WorkerMetadata> {
                unsafe {
                    #[repr(align(8))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 72]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 72]);
                    let WorkerId {
                        component_id: component_id0,
                        worker_name: worker_name0,
                    } = worker_id;
                    let ComponentId { uuid: uuid1 } = component_id0;
                    let Uuid { high_bits: high_bits2, low_bits: low_bits2 } = uuid1;
                    let vec3 = worker_name0;
                    let ptr3 = vec3.as_ptr().cast::<u8>();
                    let len3 = vec3.len();
                    let ptr4 = ret_area.0.as_mut_ptr().cast::<u8>();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "get-worker-metadata"]
                        fn wit_import(_: i64, _: i64, _: *mut u8, _: usize, _: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i64, _: i64, _: *mut u8, _: usize, _: *mut u8) {
                        unreachable!()
                    }
                    wit_import(
                        _rt::as_i64(high_bits2),
                        _rt::as_i64(low_bits2),
                        ptr3.cast_mut(),
                        len3,
                        ptr4,
                    );
                    let l5 = i32::from(*ptr4.add(0).cast::<u8>());
                    match l5 {
                        0 => None,
                        1 => {
                            let e = {
                                let l6 = *ptr4.add(8).cast::<i64>();
                                let l7 = *ptr4.add(16).cast::<i64>();
                                let l8 = *ptr4.add(24).cast::<*mut u8>();
                                let l9 = *ptr4.add(28).cast::<usize>();
                                let len10 = l9;
                                let bytes10 = _rt::Vec::from_raw_parts(
                                    l8.cast(),
                                    len10,
                                    len10,
                                );
                                let l11 = *ptr4.add(32).cast::<*mut u8>();
                                let l12 = *ptr4.add(36).cast::<usize>();
                                let base16 = l11;
                                let len16 = l12;
                                let mut result16 = _rt::Vec::with_capacity(len16);
                                for i in 0..len16 {
                                    let base = base16.add(i * 8);
                                    let e16 = {
                                        let l13 = *base.add(0).cast::<*mut u8>();
                                        let l14 = *base.add(4).cast::<usize>();
                                        let len15 = l14;
                                        let bytes15 = _rt::Vec::from_raw_parts(
                                            l13.cast(),
                                            len15,
                                            len15,
                                        );
                                        _rt::string_lift(bytes15)
                                    };
                                    result16.push(e16);
                                }
                                _rt::cabi_dealloc(base16, len16 * 8, 4);
                                let l17 = *ptr4.add(40).cast::<*mut u8>();
                                let l18 = *ptr4.add(44).cast::<usize>();
                                let base25 = l17;
                                let len25 = l18;
                                let mut result25 = _rt::Vec::with_capacity(len25);
                                for i in 0..len25 {
                                    let base = base25.add(i * 16);
                                    let e25 = {
                                        let l19 = *base.add(0).cast::<*mut u8>();
                                        let l20 = *base.add(4).cast::<usize>();
                                        let len21 = l20;
                                        let bytes21 = _rt::Vec::from_raw_parts(
                                            l19.cast(),
                                            len21,
                                            len21,
                                        );
                                        let l22 = *base.add(8).cast::<*mut u8>();
                                        let l23 = *base.add(12).cast::<usize>();
                                        let len24 = l23;
                                        let bytes24 = _rt::Vec::from_raw_parts(
                                            l22.cast(),
                                            len24,
                                            len24,
                                        );
                                        (_rt::string_lift(bytes21), _rt::string_lift(bytes24))
                                    };
                                    result25.push(e25);
                                }
                                _rt::cabi_dealloc(base25, len25 * 16, 4);
                                let l26 = i32::from(*ptr4.add(48).cast::<u8>());
                                let l27 = *ptr4.add(56).cast::<i64>();
                                let l28 = *ptr4.add(64).cast::<i64>();
                                WorkerMetadata {
                                    worker_id: WorkerId {
                                        component_id: ComponentId {
                                            uuid: Uuid {
                                                high_bits: l6 as u64,
                                                low_bits: l7 as u64,
                                            },
                                        },
                                        worker_name: _rt::string_lift(bytes10),
                                    },
                                    args: result16,
                                    env: result25,
                                    status: WorkerStatus::_lift(l26 as u8),
                                    component_version: l27 as u64,
                                    retry_count: l28 as u64,
                                }
                            };
                            Some(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Fork a worker to another worker at a given oplog index
            pub fn fork_worker(
                source_worker_id: &WorkerId,
                target_worker_id: &WorkerId,
                oplog_idx_cut_off: OplogIndex,
            ) {
                unsafe {
                    let WorkerId {
                        component_id: component_id0,
                        worker_name: worker_name0,
                    } = source_worker_id;
                    let ComponentId { uuid: uuid1 } = component_id0;
                    let Uuid { high_bits: high_bits2, low_bits: low_bits2 } = uuid1;
                    let vec3 = worker_name0;
                    let ptr3 = vec3.as_ptr().cast::<u8>();
                    let len3 = vec3.len();
                    let WorkerId {
                        component_id: component_id4,
                        worker_name: worker_name4,
                    } = target_worker_id;
                    let ComponentId { uuid: uuid5 } = component_id4;
                    let Uuid { high_bits: high_bits6, low_bits: low_bits6 } = uuid5;
                    let vec7 = worker_name4;
                    let ptr7 = vec7.as_ptr().cast::<u8>();
                    let len7 = vec7.len();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "fork-worker"]
                        fn wit_import(
                            _: i64,
                            _: i64,
                            _: *mut u8,
                            _: usize,
                            _: i64,
                            _: i64,
                            _: *mut u8,
                            _: usize,
                            _: i64,
                        );
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(
                        _: i64,
                        _: i64,
                        _: *mut u8,
                        _: usize,
                        _: i64,
                        _: i64,
                        _: *mut u8,
                        _: usize,
                        _: i64,
                    ) {
                        unreachable!()
                    }
                    wit_import(
                        _rt::as_i64(high_bits2),
                        _rt::as_i64(low_bits2),
                        ptr3.cast_mut(),
                        len3,
                        _rt::as_i64(high_bits6),
                        _rt::as_i64(low_bits6),
                        ptr7.cast_mut(),
                        len7,
                        _rt::as_i64(oplog_idx_cut_off),
                    );
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Revert a worker to a previous state
            pub fn revert_worker(
                worker_id: &WorkerId,
                revert_target: RevertWorkerTarget,
            ) {
                unsafe {
                    let WorkerId {
                        component_id: component_id0,
                        worker_name: worker_name0,
                    } = worker_id;
                    let ComponentId { uuid: uuid1 } = component_id0;
                    let Uuid { high_bits: high_bits2, low_bits: low_bits2 } = uuid1;
                    let vec3 = worker_name0;
                    let ptr3 = vec3.as_ptr().cast::<u8>();
                    let len3 = vec3.len();
                    let (result4_0, result4_1) = match revert_target {
                        RevertWorkerTarget::RevertToOplogIndex(e) => {
                            (0i32, _rt::as_i64(e))
                        }
                        RevertWorkerTarget::RevertLastInvocations(e) => {
                            (1i32, _rt::as_i64(e))
                        }
                    };
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "revert-worker"]
                        fn wit_import(
                            _: i64,
                            _: i64,
                            _: *mut u8,
                            _: usize,
                            _: i32,
                            _: i64,
                        );
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i64, _: i64, _: *mut u8, _: usize, _: i32, _: i64) {
                        unreachable!()
                    }
                    wit_import(
                        _rt::as_i64(high_bits2),
                        _rt::as_i64(low_bits2),
                        ptr3.cast_mut(),
                        len3,
                        result4_0,
                        result4_1,
                    );
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Get the component-id for a given component reference.
            /// Returns none when no component with the specified reference exists.
            /// The syntax of the component reference is implementation dependent.
            ///
            /// Golem OSS: "{component_name}"
            /// Golem Cloud:
            /// 1: "{component_name}" -> will resolve in current account and project
            /// 2: "{project_name}/{component_name}" -> will resolve in current account
            /// 3: "{account_id}/{project_name}/{component_name}"
            pub fn resolve_component_id(
                component_reference: &str,
            ) -> Option<ComponentId> {
                unsafe {
                    #[repr(align(8))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 24]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 24]);
                    let vec0 = component_reference;
                    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 = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "resolve-component-id"]
                        fn wit_import(_: *mut u8, _: usize, _: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: *mut u8, _: usize, _: *mut u8) {
                        unreachable!()
                    }
                    wit_import(ptr0.cast_mut(), len0, ptr1);
                    let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                    match l2 {
                        0 => None,
                        1 => {
                            let e = {
                                let l3 = *ptr1.add(8).cast::<i64>();
                                let l4 = *ptr1.add(16).cast::<i64>();
                                ComponentId {
                                    uuid: Uuid {
                                        high_bits: l3 as u64,
                                        low_bits: l4 as u64,
                                    },
                                }
                            };
                            Some(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Get the worker-id for a given component and worker name.
            /// Returns none when no component for the specified reference exists.
            pub fn resolve_worker_id(
                component_reference: &str,
                worker_name: &str,
            ) -> Option<WorkerId> {
                unsafe {
                    #[repr(align(8))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 32]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 32]);
                    let vec0 = component_reference;
                    let ptr0 = vec0.as_ptr().cast::<u8>();
                    let len0 = vec0.len();
                    let vec1 = worker_name;
                    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 = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "resolve-worker-id"]
                        fn wit_import(
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        );
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                    ) {
                        unreachable!()
                    }
                    wit_import(ptr0.cast_mut(), len0, ptr1.cast_mut(), len1, ptr2);
                    let l3 = i32::from(*ptr2.add(0).cast::<u8>());
                    match l3 {
                        0 => None,
                        1 => {
                            let e = {
                                let l4 = *ptr2.add(8).cast::<i64>();
                                let l5 = *ptr2.add(16).cast::<i64>();
                                let l6 = *ptr2.add(24).cast::<*mut u8>();
                                let l7 = *ptr2.add(28).cast::<usize>();
                                let len8 = l7;
                                let bytes8 = _rt::Vec::from_raw_parts(
                                    l6.cast(),
                                    len8,
                                    len8,
                                );
                                WorkerId {
                                    component_id: ComponentId {
                                        uuid: Uuid {
                                            high_bits: l4 as u64,
                                            low_bits: l5 as u64,
                                        },
                                    },
                                    worker_name: _rt::string_lift(bytes8),
                                }
                            };
                            Some(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Get the worker-id for a given component and worker name.
            /// Returns none when no component for the specified component-reference or no worker with the specified worker-name exists.
            pub fn resolve_worker_id_strict(
                component_reference: &str,
                worker_name: &str,
            ) -> Option<WorkerId> {
                unsafe {
                    #[repr(align(8))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 32]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 32]);
                    let vec0 = component_reference;
                    let ptr0 = vec0.as_ptr().cast::<u8>();
                    let len0 = vec0.len();
                    let vec1 = worker_name;
                    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 = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "resolve-worker-id-strict"]
                        fn wit_import(
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        );
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                    ) {
                        unreachable!()
                    }
                    wit_import(ptr0.cast_mut(), len0, ptr1.cast_mut(), len1, ptr2);
                    let l3 = i32::from(*ptr2.add(0).cast::<u8>());
                    match l3 {
                        0 => None,
                        1 => {
                            let e = {
                                let l4 = *ptr2.add(8).cast::<i64>();
                                let l5 = *ptr2.add(16).cast::<i64>();
                                let l6 = *ptr2.add(24).cast::<*mut u8>();
                                let l7 = *ptr2.add(28).cast::<usize>();
                                let len8 = l7;
                                let bytes8 = _rt::Vec::from_raw_parts(
                                    l6.cast(),
                                    len8,
                                    len8,
                                );
                                WorkerId {
                                    component_id: ComponentId {
                                        uuid: Uuid {
                                            high_bits: l4 as u64,
                                            low_bits: l5 as u64,
                                        },
                                    },
                                    worker_name: _rt::string_lift(bytes8),
                                }
                            };
                            Some(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Construct an uri for a given worker id.
            pub fn worker_uri(worker_id: &WorkerId) -> Uri {
                unsafe {
                    #[repr(align(4))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]);
                    let WorkerId {
                        component_id: component_id0,
                        worker_name: worker_name0,
                    } = worker_id;
                    let ComponentId { uuid: uuid1 } = component_id0;
                    let Uuid { high_bits: high_bits2, low_bits: low_bits2 } = uuid1;
                    let vec3 = worker_name0;
                    let ptr3 = vec3.as_ptr().cast::<u8>();
                    let len3 = vec3.len();
                    let ptr4 = ret_area.0.as_mut_ptr().cast::<u8>();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/host@1.1.5")]
                    extern "C" {
                        #[link_name = "worker-uri"]
                        fn wit_import(_: i64, _: i64, _: *mut u8, _: usize, _: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i64, _: i64, _: *mut u8, _: usize, _: *mut u8) {
                        unreachable!()
                    }
                    wit_import(
                        _rt::as_i64(high_bits2),
                        _rt::as_i64(low_bits2),
                        ptr3.cast_mut(),
                        len3,
                        ptr4,
                    );
                    let l5 = *ptr4.add(0).cast::<*mut u8>();
                    let l6 = *ptr4.add(4).cast::<usize>();
                    let len7 = l6;
                    let bytes7 = _rt::Vec::from_raw_parts(l5.cast(), len7, len7);
                    super::super::super::golem::rpc::types::Uri {
                        value: _rt::string_lift(bytes7),
                    }
                }
            }
        }
        /// Invocation context support
        #[allow(dead_code, clippy::all)]
        pub mod context {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            use super::super::super::_rt;
            pub type Datetime = super::super::super::wasi::clocks::wall_clock::Datetime;
            /// Represents a unit of work or operation
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct Span {
                handle: _rt::Resource<Span>,
            }
            impl Span {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 Span {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "golem:api/context@1.1.5")]
                        extern "C" {
                            #[link_name = "[resource-drop]span"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            /// Represents an invocation context wich allows querying the stack of attributes
            /// created by automatic and user-defined spans.
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct InvocationContext {
                handle: _rt::Resource<InvocationContext>,
            }
            impl InvocationContext {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 InvocationContext {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "golem:api/context@1.1.5")]
                        extern "C" {
                            #[link_name = "[resource-drop]invocation-context"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            /// Possible span attribute value types
            #[derive(Clone)]
            pub enum AttributeValue {
                /// A string value
                String(_rt::String),
            }
            impl ::core::fmt::Debug for AttributeValue {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        AttributeValue::String(e) => {
                            f.debug_tuple("AttributeValue::String").field(e).finish()
                        }
                    }
                }
            }
            /// An attribute of a span
            #[derive(Clone)]
            pub struct Attribute {
                pub key: _rt::String,
                pub value: AttributeValue,
            }
            impl ::core::fmt::Debug for Attribute {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Attribute")
                        .field("key", &self.key)
                        .field("value", &self.value)
                        .finish()
                }
            }
            /// A chain of attribute values, the first element representing the most recent value
            #[derive(Clone)]
            pub struct AttributeChain {
                pub key: _rt::String,
                pub values: _rt::Vec<AttributeValue>,
            }
            impl ::core::fmt::Debug for AttributeChain {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("AttributeChain")
                        .field("key", &self.key)
                        .field("values", &self.values)
                        .finish()
                }
            }
            /// The trace represented by a 16 bytes hexadecimal string
            pub type TraceId = _rt::String;
            /// The span represented by a 8 bytes hexadecimal string
            pub type SpanId = _rt::String;
            #[allow(unused_unsafe, clippy::all)]
            /// Starts a new `span` with the given name, as a child of the current invocation context
            pub fn start_span(name: &str) -> Span {
                unsafe {
                    let vec0 = name;
                    let ptr0 = vec0.as_ptr().cast::<u8>();
                    let len0 = vec0.len();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/context@1.1.5")]
                    extern "C" {
                        #[link_name = "start-span"]
                        fn wit_import(_: *mut u8, _: usize) -> i32;
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: *mut u8, _: usize) -> i32 {
                        unreachable!()
                    }
                    let ret = wit_import(ptr0.cast_mut(), len0);
                    Span::from_handle(ret as u32)
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Gets the current invocation context
            ///
            /// The function call captures the current context; if new spans are started, the returned `invocation-context` instance will not
            /// reflect that.
            pub fn current_context() -> InvocationContext {
                unsafe {
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/context@1.1.5")]
                    extern "C" {
                        #[link_name = "current-context"]
                        fn wit_import() -> i32;
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import() -> i32 {
                        unreachable!()
                    }
                    let ret = wit_import();
                    InvocationContext::from_handle(ret as u32)
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Allows or disallows forwarding of trace context headers in outgoing HTTP requests
            ///
            /// Returns the previous value of the setting
            pub fn allow_forwarding_trace_context_headers(allow: bool) -> bool {
                unsafe {
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:api/context@1.1.5")]
                    extern "C" {
                        #[link_name = "allow-forwarding-trace-context-headers"]
                        fn wit_import(_: i32) -> i32;
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i32) -> i32 {
                        unreachable!()
                    }
                    let ret = wit_import(
                        match &allow {
                            true => 1,
                            false => 0,
                        },
                    );
                    _rt::bool_lift(ret as u8)
                }
            }
            impl Span {
                #[allow(unused_unsafe, clippy::all)]
                /// Gets the starting time of the span
                pub fn started_at(&self) -> Datetime {
                    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 = "golem:api/context@1.1.5")]
                        extern "C" {
                            #[link_name = "[method]span.started-at"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = *ptr0.add(0).cast::<i64>();
                        let l2 = *ptr0.add(8).cast::<i32>();
                        super::super::super::wasi::clocks::wall_clock::Datetime {
                            seconds: l1 as u64,
                            nanoseconds: l2 as u32,
                        }
                    }
                }
            }
            impl Span {
                #[allow(unused_unsafe, clippy::all)]
                /// Set an attribute on the span
                pub fn set_attribute(&self, name: &str, value: &AttributeValue) {
                    unsafe {
                        let vec0 = name;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let (result2_0, result2_1, result2_2) = match value {
                            AttributeValue::String(e) => {
                                let vec1 = e;
                                let ptr1 = vec1.as_ptr().cast::<u8>();
                                let len1 = vec1.len();
                                (0i32, ptr1.cast_mut(), len1)
                            }
                        };
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:api/context@1.1.5")]
                        extern "C" {
                            #[link_name = "[method]span.set-attribute"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: i32,
                                _: *mut u8,
                                _: usize,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: i32,
                            _: *mut u8,
                            _: usize,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            result2_0,
                            result2_1,
                            result2_2,
                        );
                    }
                }
            }
            impl Span {
                #[allow(unused_unsafe, clippy::all)]
                /// Set multiple attributes on the span
                pub fn set_attributes(&self, attributes: &[Attribute]) {
                    unsafe {
                        let vec3 = attributes;
                        let len3 = vec3.len();
                        let layout3 = _rt::alloc::Layout::from_size_align_unchecked(
                            vec3.len() * 20,
                            4,
                        );
                        let result3 = if layout3.size() != 0 {
                            let ptr = _rt::alloc::alloc(layout3).cast::<u8>();
                            if ptr.is_null() {
                                _rt::alloc::handle_alloc_error(layout3);
                            }
                            ptr
                        } else {
                            ::core::ptr::null_mut()
                        };
                        for (i, e) in vec3.into_iter().enumerate() {
                            let base = result3.add(i * 20);
                            {
                                let Attribute { key: key0, value: value0 } = e;
                                let vec1 = key0;
                                let ptr1 = vec1.as_ptr().cast::<u8>();
                                let len1 = vec1.len();
                                *base.add(4).cast::<usize>() = len1;
                                *base.add(0).cast::<*mut u8>() = ptr1.cast_mut();
                                match value0 {
                                    AttributeValue::String(e) => {
                                        *base.add(8).cast::<u8>() = (0i32) as u8;
                                        let vec2 = e;
                                        let ptr2 = vec2.as_ptr().cast::<u8>();
                                        let len2 = vec2.len();
                                        *base.add(16).cast::<usize>() = len2;
                                        *base.add(12).cast::<*mut u8>() = ptr2.cast_mut();
                                    }
                                }
                            }
                        }
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:api/context@1.1.5")]
                        extern "C" {
                            #[link_name = "[method]span.set-attributes"]
                            fn wit_import(_: i32, _: *mut u8, _: usize);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8, _: usize) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, result3, len3);
                        if layout3.size() != 0 {
                            _rt::alloc::dealloc(result3.cast(), layout3);
                        }
                    }
                }
            }
            impl Span {
                #[allow(unused_unsafe, clippy::all)]
                /// Early finishes the span; otherwise it will be finished when the resource is dropped
                pub fn finish(&self) {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:api/context@1.1.5")]
                        extern "C" {
                            #[link_name = "[method]span.finish"]
                            fn wit_import(_: i32);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32);
                    }
                }
            }
            impl InvocationContext {
                #[allow(unused_unsafe, clippy::all)]
                /// Gets the current trace id
                pub fn trace_id(&self) -> TraceId {
                    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 = "golem:api/context@1.1.5")]
                        extern "C" {
                            #[link_name = "[method]invocation-context.trace-id"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = *ptr0.add(0).cast::<*mut u8>();
                        let l2 = *ptr0.add(4).cast::<usize>();
                        let len3 = l2;
                        let bytes3 = _rt::Vec::from_raw_parts(l1.cast(), len3, len3);
                        _rt::string_lift(bytes3)
                    }
                }
            }
            impl InvocationContext {
                #[allow(unused_unsafe, clippy::all)]
                /// Gets the current span id
                pub fn span_id(&self) -> SpanId {
                    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 = "golem:api/context@1.1.5")]
                        extern "C" {
                            #[link_name = "[method]invocation-context.span-id"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = *ptr0.add(0).cast::<*mut u8>();
                        let l2 = *ptr0.add(4).cast::<usize>();
                        let len3 = l2;
                        let bytes3 = _rt::Vec::from_raw_parts(l1.cast(), len3, len3);
                        _rt::string_lift(bytes3)
                    }
                }
            }
            impl InvocationContext {
                #[allow(unused_unsafe, clippy::all)]
                /// Gets the parent context, if any; allows recursive processing of the invocation context.
                ///
                /// Alternatively, the attribute query methods can return inherited values without having to
                /// traverse the stack manually.
                pub fn parent(&self) -> Option<InvocationContext> {
                    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 = "golem:api/context@1.1.5")]
                        extern "C" {
                            #[link_name = "[method]invocation-context.parent"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<i32>();
                                    InvocationContext::from_handle(l2 as u32)
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl InvocationContext {
                #[allow(unused_unsafe, clippy::all)]
                /// Gets the value of an attribute `key`. If `inherited` is true, the value is searched in the stack of spans,
                /// otherwise only in the current span.
                pub fn get_attribute(
                    &self,
                    key: &str,
                    inherited: bool,
                ) -> Option<AttributeValue> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 16]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 16],
                        );
                        let vec0 = key;
                        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 = "golem:api/context@1.1.5")]
                        extern "C" {
                            #[link_name = "[method]invocation-context.get-attribute"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: i32,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            match &inherited {
                                true => 1,
                                false => 0,
                            },
                            ptr1,
                        );
                        let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                        match l2 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l3 = i32::from(*ptr1.add(4).cast::<u8>());
                                    let v7 = match l3 {
                                        n => {
                                            debug_assert_eq!(n, 0, "invalid enum discriminant");
                                            let e7 = {
                                                let l4 = *ptr1.add(8).cast::<*mut u8>();
                                                let l5 = *ptr1.add(12).cast::<usize>();
                                                let len6 = l5;
                                                let bytes6 = _rt::Vec::from_raw_parts(
                                                    l4.cast(),
                                                    len6,
                                                    len6,
                                                );
                                                _rt::string_lift(bytes6)
                                            };
                                            AttributeValue::String(e7)
                                        }
                                    };
                                    v7
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl InvocationContext {
                #[allow(unused_unsafe, clippy::all)]
                /// Gets all attributes of the current invocation context. If `inherited` is true, it returns the merged set of attributes, each
                /// key associated with the latest value found in the stack of spans.
                pub fn get_attributes(&self, inherited: bool) -> _rt::Vec<Attribute> {
                    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 = "golem:api/context@1.1.5")]
                        extern "C" {
                            #[link_name = "[method]invocation-context.get-attributes"]
                            fn wit_import(_: i32, _: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            match &inherited {
                                true => 1,
                                false => 0,
                            },
                            ptr0,
                        );
                        let l1 = *ptr0.add(0).cast::<*mut u8>();
                        let l2 = *ptr0.add(4).cast::<usize>();
                        let base11 = l1;
                        let len11 = l2;
                        let mut result11 = _rt::Vec::with_capacity(len11);
                        for i in 0..len11 {
                            let base = base11.add(i * 20);
                            let e11 = {
                                let l3 = *base.add(0).cast::<*mut u8>();
                                let l4 = *base.add(4).cast::<usize>();
                                let len5 = l4;
                                let bytes5 = _rt::Vec::from_raw_parts(
                                    l3.cast(),
                                    len5,
                                    len5,
                                );
                                let l6 = i32::from(*base.add(8).cast::<u8>());
                                let v10 = match l6 {
                                    n => {
                                        debug_assert_eq!(n, 0, "invalid enum discriminant");
                                        let e10 = {
                                            let l7 = *base.add(12).cast::<*mut u8>();
                                            let l8 = *base.add(16).cast::<usize>();
                                            let len9 = l8;
                                            let bytes9 = _rt::Vec::from_raw_parts(
                                                l7.cast(),
                                                len9,
                                                len9,
                                            );
                                            _rt::string_lift(bytes9)
                                        };
                                        AttributeValue::String(e10)
                                    }
                                };
                                Attribute {
                                    key: _rt::string_lift(bytes5),
                                    value: v10,
                                }
                            };
                            result11.push(e11);
                        }
                        _rt::cabi_dealloc(base11, len11 * 20, 4);
                        result11
                    }
                }
            }
            impl InvocationContext {
                #[allow(unused_unsafe, clippy::all)]
                /// Gets the chain of attribute values associated with the given `key`. If the key does not exist in any of the
                /// spans in the invocation context, the list is empty. The chain's first element contains the most recent (innermost) value.
                pub fn get_attribute_chain(
                    &self,
                    key: &str,
                ) -> _rt::Vec<AttributeValue> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 8],
                        );
                        let vec0 = key;
                        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 = "golem:api/context@1.1.5")]
                        extern "C" {
                            #[link_name = "[method]invocation-context.get-attribute-chain"]
                            fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0.cast_mut(), len0, ptr1);
                        let l2 = *ptr1.add(0).cast::<*mut u8>();
                        let l3 = *ptr1.add(4).cast::<usize>();
                        let base9 = l2;
                        let len9 = l3;
                        let mut result9 = _rt::Vec::with_capacity(len9);
                        for i in 0..len9 {
                            let base = base9.add(i * 12);
                            let e9 = {
                                let l4 = i32::from(*base.add(0).cast::<u8>());
                                let v8 = match l4 {
                                    n => {
                                        debug_assert_eq!(n, 0, "invalid enum discriminant");
                                        let e8 = {
                                            let l5 = *base.add(4).cast::<*mut u8>();
                                            let l6 = *base.add(8).cast::<usize>();
                                            let len7 = l6;
                                            let bytes7 = _rt::Vec::from_raw_parts(
                                                l5.cast(),
                                                len7,
                                                len7,
                                            );
                                            _rt::string_lift(bytes7)
                                        };
                                        AttributeValue::String(e8)
                                    }
                                };
                                v8
                            };
                            result9.push(e9);
                        }
                        _rt::cabi_dealloc(base9, len9 * 12, 4);
                        result9
                    }
                }
            }
            impl InvocationContext {
                #[allow(unused_unsafe, clippy::all)]
                /// Gets all values of all attributes of the current invocation context.
                pub fn get_attribute_chains(&self) -> _rt::Vec<AttributeChain> {
                    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 = "golem:api/context@1.1.5")]
                        extern "C" {
                            #[link_name = "[method]invocation-context.get-attribute-chains"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = *ptr0.add(0).cast::<*mut u8>();
                        let l2 = *ptr0.add(4).cast::<usize>();
                        let base14 = l1;
                        let len14 = l2;
                        let mut result14 = _rt::Vec::with_capacity(len14);
                        for i in 0..len14 {
                            let base = base14.add(i * 16);
                            let e14 = {
                                let l3 = *base.add(0).cast::<*mut u8>();
                                let l4 = *base.add(4).cast::<usize>();
                                let len5 = l4;
                                let bytes5 = _rt::Vec::from_raw_parts(
                                    l3.cast(),
                                    len5,
                                    len5,
                                );
                                let l6 = *base.add(8).cast::<*mut u8>();
                                let l7 = *base.add(12).cast::<usize>();
                                let base13 = l6;
                                let len13 = l7;
                                let mut result13 = _rt::Vec::with_capacity(len13);
                                for i in 0..len13 {
                                    let base = base13.add(i * 12);
                                    let e13 = {
                                        let l8 = i32::from(*base.add(0).cast::<u8>());
                                        let v12 = match l8 {
                                            n => {
                                                debug_assert_eq!(n, 0, "invalid enum discriminant");
                                                let e12 = {
                                                    let l9 = *base.add(4).cast::<*mut u8>();
                                                    let l10 = *base.add(8).cast::<usize>();
                                                    let len11 = l10;
                                                    let bytes11 = _rt::Vec::from_raw_parts(
                                                        l9.cast(),
                                                        len11,
                                                        len11,
                                                    );
                                                    _rt::string_lift(bytes11)
                                                };
                                                AttributeValue::String(e12)
                                            }
                                        };
                                        v12
                                    };
                                    result13.push(e13);
                                }
                                _rt::cabi_dealloc(base13, len13 * 12, 4);
                                AttributeChain {
                                    key: _rt::string_lift(bytes5),
                                    values: result13,
                                }
                            };
                            result14.push(e14);
                        }
                        _rt::cabi_dealloc(base14, len14 * 16, 4);
                        result14
                    }
                }
            }
            impl InvocationContext {
                #[allow(unused_unsafe, clippy::all)]
                /// Gets the W3C Trace Context headers associated with the current invocation context
                pub fn trace_context_headers(
                    &self,
                ) -> _rt::Vec<(_rt::String, _rt::String)> {
                    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 = "golem:api/context@1.1.5")]
                        extern "C" {
                            #[link_name = "[method]invocation-context.trace-context-headers"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = *ptr0.add(0).cast::<*mut u8>();
                        let l2 = *ptr0.add(4).cast::<usize>();
                        let base9 = l1;
                        let len9 = l2;
                        let mut result9 = _rt::Vec::with_capacity(len9);
                        for i in 0..len9 {
                            let base = base9.add(i * 16);
                            let e9 = {
                                let l3 = *base.add(0).cast::<*mut u8>();
                                let l4 = *base.add(4).cast::<usize>();
                                let len5 = l4;
                                let bytes5 = _rt::Vec::from_raw_parts(
                                    l3.cast(),
                                    len5,
                                    len5,
                                );
                                let l6 = *base.add(8).cast::<*mut u8>();
                                let l7 = *base.add(12).cast::<usize>();
                                let len8 = l7;
                                let bytes8 = _rt::Vec::from_raw_parts(
                                    l6.cast(),
                                    len8,
                                    len8,
                                );
                                (_rt::string_lift(bytes5), _rt::string_lift(bytes8))
                            };
                            result9.push(e9);
                        }
                        _rt::cabi_dealloc(base9, len9 * 16, 4);
                        result9
                    }
                }
            }
        }
        /// Host interface for enumerating and searching for worker oplogs
        #[allow(dead_code, clippy::all)]
        pub mod oplog {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            use super::super::super::_rt;
            pub type Datetime = super::super::super::wasi::clocks::wall_clock::Datetime;
            pub type WitValue = super::super::super::golem::rpc::types::WitValue;
            pub type AccountId = super::super::super::golem::api::host::AccountId;
            pub type ComponentVersion = super::super::super::golem::api::host::ComponentVersion;
            pub type OplogIndex = super::super::super::golem::api::host::OplogIndex;
            pub type RetryPolicy = super::super::super::golem::api::host::RetryPolicy;
            pub type Uuid = super::super::super::golem::api::host::Uuid;
            pub type WorkerId = super::super::super::golem::api::host::WorkerId;
            pub type Attribute = super::super::super::golem::api::context::Attribute;
            pub type AttributeValue = super::super::super::golem::api::context::AttributeValue;
            pub type SpanId = super::super::super::golem::api::context::SpanId;
            pub type TraceId = super::super::super::golem::api::context::TraceId;
            #[derive(Clone, Copy)]
            pub enum WrappedFunctionType {
                /// The side-effect reads from the worker's local state (for example local file system,
                /// random generator, etc.)
                ReadLocal,
                /// The side-effect writes to the worker's local state (for example local file system)
                WriteLocal,
                /// The side-effect reads from external state (for example a key-value store)
                ReadRemote,
                /// The side-effect manipulates external state (for example an RPC call)
                WriteRemote,
                /// The side-effect manipulates external state through multiple invoked functions (for example
                /// a HTTP request where reading the response involves multiple host function calls)
                ///
                /// On the first invocation of the batch, the parameter should be `None` - this triggers
                /// writing a `BeginRemoteWrite` entry in the oplog. Followup invocations should contain
                /// this entry's index as the parameter. In batched remote writes it is the caller's responsibility
                /// to manually write an `EndRemoteWrite` entry (using `end_function`) when the operation is completed.
                WriteRemoteBatched(Option<OplogIndex>),
            }
            impl ::core::fmt::Debug for WrappedFunctionType {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        WrappedFunctionType::ReadLocal => {
                            f.debug_tuple("WrappedFunctionType::ReadLocal").finish()
                        }
                        WrappedFunctionType::WriteLocal => {
                            f.debug_tuple("WrappedFunctionType::WriteLocal").finish()
                        }
                        WrappedFunctionType::ReadRemote => {
                            f.debug_tuple("WrappedFunctionType::ReadRemote").finish()
                        }
                        WrappedFunctionType::WriteRemote => {
                            f.debug_tuple("WrappedFunctionType::WriteRemote").finish()
                        }
                        WrappedFunctionType::WriteRemoteBatched(e) => {
                            f.debug_tuple("WrappedFunctionType::WriteRemoteBatched")
                                .field(e)
                                .finish()
                        }
                    }
                }
            }
            #[derive(Clone)]
            pub struct PluginInstallationDescription {
                pub installation_id: Uuid,
                pub name: _rt::String,
                pub version: _rt::String,
                pub parameters: _rt::Vec<(_rt::String, _rt::String)>,
            }
            impl ::core::fmt::Debug for PluginInstallationDescription {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("PluginInstallationDescription")
                        .field("installation-id", &self.installation_id)
                        .field("name", &self.name)
                        .field("version", &self.version)
                        .field("parameters", &self.parameters)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub struct CreateParameters {
                pub timestamp: Datetime,
                pub worker_id: WorkerId,
                pub component_version: ComponentVersion,
                pub args: _rt::Vec<_rt::String>,
                pub env: _rt::Vec<(_rt::String, _rt::String)>,
                pub account_id: AccountId,
                pub parent: Option<WorkerId>,
                pub component_size: u64,
                pub initial_total_linear_memory_size: u64,
                pub initial_active_plugins: _rt::Vec<PluginInstallationDescription>,
            }
            impl ::core::fmt::Debug for CreateParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("CreateParameters")
                        .field("timestamp", &self.timestamp)
                        .field("worker-id", &self.worker_id)
                        .field("component-version", &self.component_version)
                        .field("args", &self.args)
                        .field("env", &self.env)
                        .field("account-id", &self.account_id)
                        .field("parent", &self.parent)
                        .field("component-size", &self.component_size)
                        .field(
                            "initial-total-linear-memory-size",
                            &self.initial_total_linear_memory_size,
                        )
                        .field("initial-active-plugins", &self.initial_active_plugins)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub struct ImportedFunctionInvokedParameters {
                pub timestamp: Datetime,
                pub function_name: _rt::String,
                pub request: WitValue,
                pub response: WitValue,
                pub wrapped_function_type: WrappedFunctionType,
            }
            impl ::core::fmt::Debug for ImportedFunctionInvokedParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("ImportedFunctionInvokedParameters")
                        .field("timestamp", &self.timestamp)
                        .field("function-name", &self.function_name)
                        .field("request", &self.request)
                        .field("response", &self.response)
                        .field("wrapped-function-type", &self.wrapped_function_type)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub struct LocalSpanData {
                pub span_id: SpanId,
                pub start: Datetime,
                pub parent: Option<SpanId>,
                /// Optionally an index of the exported-function-invoked-parameters's invocation-context field
                pub linked_context: Option<u64>,
                pub attributes: _rt::Vec<Attribute>,
                pub inherited: bool,
            }
            impl ::core::fmt::Debug for LocalSpanData {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("LocalSpanData")
                        .field("span-id", &self.span_id)
                        .field("start", &self.start)
                        .field("parent", &self.parent)
                        .field("linked-context", &self.linked_context)
                        .field("attributes", &self.attributes)
                        .field("inherited", &self.inherited)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub struct ExternalSpanData {
                pub span_id: SpanId,
            }
            impl ::core::fmt::Debug for ExternalSpanData {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("ExternalSpanData")
                        .field("span-id", &self.span_id)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub enum SpanData {
                LocalSpan(LocalSpanData),
                ExternalSpan(ExternalSpanData),
            }
            impl ::core::fmt::Debug for SpanData {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        SpanData::LocalSpan(e) => {
                            f.debug_tuple("SpanData::LocalSpan").field(e).finish()
                        }
                        SpanData::ExternalSpan(e) => {
                            f.debug_tuple("SpanData::ExternalSpan").field(e).finish()
                        }
                    }
                }
            }
            #[derive(Clone)]
            pub struct ExportedFunctionInvokedParameters {
                pub timestamp: Datetime,
                pub function_name: _rt::String,
                pub request: _rt::Vec<WitValue>,
                pub idempotency_key: _rt::String,
                pub trace_id: TraceId,
                pub trace_states: _rt::Vec<_rt::String>,
                /// The first one is the invocation context stack associated with the exported function invocation,
                /// and further stacks can be added that are referenced by the `linked-context` field of `local-span-data`
                pub invocation_context: _rt::Vec<_rt::Vec<SpanData>>,
            }
            impl ::core::fmt::Debug for ExportedFunctionInvokedParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("ExportedFunctionInvokedParameters")
                        .field("timestamp", &self.timestamp)
                        .field("function-name", &self.function_name)
                        .field("request", &self.request)
                        .field("idempotency-key", &self.idempotency_key)
                        .field("trace-id", &self.trace_id)
                        .field("trace-states", &self.trace_states)
                        .field("invocation-context", &self.invocation_context)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub struct ExportedFunctionCompletedParameters {
                pub timestamp: Datetime,
                pub response: WitValue,
                pub consumed_fuel: i64,
            }
            impl ::core::fmt::Debug for ExportedFunctionCompletedParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("ExportedFunctionCompletedParameters")
                        .field("timestamp", &self.timestamp)
                        .field("response", &self.response)
                        .field("consumed-fuel", &self.consumed_fuel)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub struct ErrorParameters {
                pub timestamp: Datetime,
                pub error: _rt::String,
            }
            impl ::core::fmt::Debug for ErrorParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("ErrorParameters")
                        .field("timestamp", &self.timestamp)
                        .field("error", &self.error)
                        .finish()
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct JumpParameters {
                pub timestamp: Datetime,
                pub start: OplogIndex,
                pub end: OplogIndex,
            }
            impl ::core::fmt::Debug for JumpParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("JumpParameters")
                        .field("timestamp", &self.timestamp)
                        .field("start", &self.start)
                        .field("end", &self.end)
                        .finish()
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct ChangeRetryPolicyParameters {
                pub timestamp: Datetime,
                pub retry_policy: RetryPolicy,
            }
            impl ::core::fmt::Debug for ChangeRetryPolicyParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("ChangeRetryPolicyParameters")
                        .field("timestamp", &self.timestamp)
                        .field("retry-policy", &self.retry_policy)
                        .finish()
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct EndAtomicRegionParameters {
                pub timestamp: Datetime,
                pub begin_index: OplogIndex,
            }
            impl ::core::fmt::Debug for EndAtomicRegionParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("EndAtomicRegionParameters")
                        .field("timestamp", &self.timestamp)
                        .field("begin-index", &self.begin_index)
                        .finish()
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct EndRemoteWriteParameters {
                pub timestamp: Datetime,
                pub begin_index: OplogIndex,
            }
            impl ::core::fmt::Debug for EndRemoteWriteParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("EndRemoteWriteParameters")
                        .field("timestamp", &self.timestamp)
                        .field("begin-index", &self.begin_index)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub struct ExportedFunctionInvocationParameters {
                pub idempotency_key: _rt::String,
                pub function_name: _rt::String,
                pub input: Option<_rt::Vec<WitValue>>,
            }
            impl ::core::fmt::Debug for ExportedFunctionInvocationParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("ExportedFunctionInvocationParameters")
                        .field("idempotency-key", &self.idempotency_key)
                        .field("function-name", &self.function_name)
                        .field("input", &self.input)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub enum WorkerInvocation {
                ExportedFunction(ExportedFunctionInvocationParameters),
                ManualUpdate(ComponentVersion),
            }
            impl ::core::fmt::Debug for WorkerInvocation {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        WorkerInvocation::ExportedFunction(e) => {
                            f.debug_tuple("WorkerInvocation::ExportedFunction")
                                .field(e)
                                .finish()
                        }
                        WorkerInvocation::ManualUpdate(e) => {
                            f.debug_tuple("WorkerInvocation::ManualUpdate")
                                .field(e)
                                .finish()
                        }
                    }
                }
            }
            #[derive(Clone)]
            pub struct PendingWorkerInvocationParameters {
                pub timestamp: Datetime,
                pub invocation: WorkerInvocation,
            }
            impl ::core::fmt::Debug for PendingWorkerInvocationParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("PendingWorkerInvocationParameters")
                        .field("timestamp", &self.timestamp)
                        .field("invocation", &self.invocation)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub enum UpdateDescription {
                /// Automatic update by replaying the oplog on the new version
                AutoUpdate,
                /// Custom update by loading a given snapshot on the new version
                SnapshotBased(_rt::Vec<u8>),
            }
            impl ::core::fmt::Debug for UpdateDescription {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        UpdateDescription::AutoUpdate => {
                            f.debug_tuple("UpdateDescription::AutoUpdate").finish()
                        }
                        UpdateDescription::SnapshotBased(e) => {
                            f.debug_tuple("UpdateDescription::SnapshotBased")
                                .field(e)
                                .finish()
                        }
                    }
                }
            }
            #[derive(Clone)]
            pub struct PendingUpdateParameters {
                pub timestamp: Datetime,
                pub target_version: ComponentVersion,
                pub update_description: UpdateDescription,
            }
            impl ::core::fmt::Debug for PendingUpdateParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("PendingUpdateParameters")
                        .field("timestamp", &self.timestamp)
                        .field("target-version", &self.target_version)
                        .field("update-description", &self.update_description)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub struct SuccessfulUpdateParameters {
                pub timestamp: Datetime,
                pub target_version: ComponentVersion,
                pub new_component_size: u64,
                pub new_active_plugins: _rt::Vec<PluginInstallationDescription>,
            }
            impl ::core::fmt::Debug for SuccessfulUpdateParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("SuccessfulUpdateParameters")
                        .field("timestamp", &self.timestamp)
                        .field("target-version", &self.target_version)
                        .field("new-component-size", &self.new_component_size)
                        .field("new-active-plugins", &self.new_active_plugins)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub struct FailedUpdateParameters {
                pub timestamp: Datetime,
                pub target_version: ComponentVersion,
                pub details: Option<_rt::String>,
            }
            impl ::core::fmt::Debug for FailedUpdateParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("FailedUpdateParameters")
                        .field("timestamp", &self.timestamp)
                        .field("target-version", &self.target_version)
                        .field("details", &self.details)
                        .finish()
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct GrowMemoryParameters {
                pub timestamp: Datetime,
                pub delta: u64,
            }
            impl ::core::fmt::Debug for GrowMemoryParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("GrowMemoryParameters")
                        .field("timestamp", &self.timestamp)
                        .field("delta", &self.delta)
                        .finish()
                }
            }
            pub type WorkerResourceId = u64;
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct CreateResourceParameters {
                pub timestamp: Datetime,
                pub resource_id: WorkerResourceId,
            }
            impl ::core::fmt::Debug for CreateResourceParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("CreateResourceParameters")
                        .field("timestamp", &self.timestamp)
                        .field("resource-id", &self.resource_id)
                        .finish()
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct DropResourceParameters {
                pub timestamp: Datetime,
                pub resource_id: WorkerResourceId,
            }
            impl ::core::fmt::Debug for DropResourceParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("DropResourceParameters")
                        .field("timestamp", &self.timestamp)
                        .field("resource-id", &self.resource_id)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub struct DescribeResourceParameters {
                pub timestamp: Datetime,
                pub resource_id: WorkerResourceId,
                pub resource_name: _rt::String,
                pub resource_params: _rt::Vec<WitValue>,
            }
            impl ::core::fmt::Debug for DescribeResourceParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("DescribeResourceParameters")
                        .field("timestamp", &self.timestamp)
                        .field("resource-id", &self.resource_id)
                        .field("resource-name", &self.resource_name)
                        .field("resource-params", &self.resource_params)
                        .finish()
                }
            }
            #[repr(u8)]
            #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
            pub enum LogLevel {
                Stdout,
                Stderr,
                Trace,
                Debug,
                Info,
                Warn,
                Error,
                Critical,
            }
            impl ::core::fmt::Debug for LogLevel {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        LogLevel::Stdout => f.debug_tuple("LogLevel::Stdout").finish(),
                        LogLevel::Stderr => f.debug_tuple("LogLevel::Stderr").finish(),
                        LogLevel::Trace => f.debug_tuple("LogLevel::Trace").finish(),
                        LogLevel::Debug => f.debug_tuple("LogLevel::Debug").finish(),
                        LogLevel::Info => f.debug_tuple("LogLevel::Info").finish(),
                        LogLevel::Warn => f.debug_tuple("LogLevel::Warn").finish(),
                        LogLevel::Error => f.debug_tuple("LogLevel::Error").finish(),
                        LogLevel::Critical => {
                            f.debug_tuple("LogLevel::Critical").finish()
                        }
                    }
                }
            }
            impl LogLevel {
                #[doc(hidden)]
                pub unsafe fn _lift(val: u8) -> LogLevel {
                    if !cfg!(debug_assertions) {
                        return ::core::mem::transmute(val);
                    }
                    match val {
                        0 => LogLevel::Stdout,
                        1 => LogLevel::Stderr,
                        2 => LogLevel::Trace,
                        3 => LogLevel::Debug,
                        4 => LogLevel::Info,
                        5 => LogLevel::Warn,
                        6 => LogLevel::Error,
                        7 => LogLevel::Critical,
                        _ => panic!("invalid enum discriminant"),
                    }
                }
            }
            #[derive(Clone)]
            pub struct LogParameters {
                pub timestamp: Datetime,
                pub level: LogLevel,
                pub context: _rt::String,
                pub message: _rt::String,
            }
            impl ::core::fmt::Debug for LogParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("LogParameters")
                        .field("timestamp", &self.timestamp)
                        .field("level", &self.level)
                        .field("context", &self.context)
                        .field("message", &self.message)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub struct ActivatePluginParameters {
                pub timestamp: Datetime,
                pub plugin: PluginInstallationDescription,
            }
            impl ::core::fmt::Debug for ActivatePluginParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("ActivatePluginParameters")
                        .field("timestamp", &self.timestamp)
                        .field("plugin", &self.plugin)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub struct DeactivatePluginParameters {
                pub timestamp: Datetime,
                pub plugin: PluginInstallationDescription,
            }
            impl ::core::fmt::Debug for DeactivatePluginParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("DeactivatePluginParameters")
                        .field("timestamp", &self.timestamp)
                        .field("plugin", &self.plugin)
                        .finish()
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct RevertParameters {
                pub timestamp: Datetime,
                pub start: OplogIndex,
                pub end: OplogIndex,
            }
            impl ::core::fmt::Debug for RevertParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("RevertParameters")
                        .field("timestamp", &self.timestamp)
                        .field("start", &self.start)
                        .field("end", &self.end)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub struct CancelInvocationParameters {
                pub timestamp: Datetime,
                pub idempotency_key: _rt::String,
            }
            impl ::core::fmt::Debug for CancelInvocationParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("CancelInvocationParameters")
                        .field("timestamp", &self.timestamp)
                        .field("idempotency-key", &self.idempotency_key)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub struct StartSpanParameters {
                pub timestamp: Datetime,
                pub span_id: SpanId,
                pub parent: Option<SpanId>,
                pub linked_context: Option<SpanId>,
                pub attributes: _rt::Vec<Attribute>,
            }
            impl ::core::fmt::Debug for StartSpanParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("StartSpanParameters")
                        .field("timestamp", &self.timestamp)
                        .field("span-id", &self.span_id)
                        .field("parent", &self.parent)
                        .field("linked-context", &self.linked_context)
                        .field("attributes", &self.attributes)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub struct FinishSpanParameters {
                pub timestamp: Datetime,
                pub span_id: SpanId,
            }
            impl ::core::fmt::Debug for FinishSpanParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("FinishSpanParameters")
                        .field("timestamp", &self.timestamp)
                        .field("span-id", &self.span_id)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub struct SetSpanAttributeParameters {
                pub timestamp: Datetime,
                pub span_id: SpanId,
                pub key: _rt::String,
                pub value: AttributeValue,
            }
            impl ::core::fmt::Debug for SetSpanAttributeParameters {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("SetSpanAttributeParameters")
                        .field("timestamp", &self.timestamp)
                        .field("span-id", &self.span_id)
                        .field("key", &self.key)
                        .field("value", &self.value)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub enum OplogEntry {
                /// The initial worker oplog entry
                Create(CreateParameters),
                /// The worker invoked a host function
                ImportedFunctionInvoked(ImportedFunctionInvokedParameters),
                /// The worker has been invoked
                ExportedFunctionInvoked(ExportedFunctionInvokedParameters),
                /// The worker has completed an invocation
                ExportedFunctionCompleted(ExportedFunctionCompletedParameters),
                /// Worker suspended
                Suspend(Datetime),
                /// Worker failed
                Error(ErrorParameters),
                /// Marker entry added when get-oplog-index is called from the worker, to make the jumping behavior
                /// more predictable.
                NoOp(Datetime),
                /// The worker needs to recover up to the given target oplog index and continue running from
                /// the source oplog index from there
                /// `jump` is an oplog region representing that from the end of that region we want to go back to the start and
                /// ignore all recorded operations in between.
                Jump(JumpParameters),
                /// Indicates that the worker has been interrupted at this point.
                /// Only used to recompute the worker's (cached) status, has no effect on execution.
                Interrupted(Datetime),
                /// Indicates that the worker has been exited using WASI's exit function.
                Exited(Datetime),
                /// Overrides the worker's retry policy
                ChangeRetryPolicy(ChangeRetryPolicyParameters),
                /// Begins an atomic region. All oplog entries after `BeginAtomicRegion` are to be ignored during
                /// recovery except if there is a corresponding `EndAtomicRegion` entry.
                BeginAtomicRegion(Datetime),
                /// Ends an atomic region. All oplog entries between the corresponding `BeginAtomicRegion` and this
                /// entry are to be considered during recovery, and the begin/end markers can be removed during oplog
                /// compaction.
                EndAtomicRegion(EndAtomicRegionParameters),
                /// Begins a remote write operation. Only used when idempotence mode is off. In this case each
                /// remote write must be surrounded by a `BeginRemoteWrite` and `EndRemoteWrite` log pair and
                /// unfinished remote writes cannot be recovered.
                BeginRemoteWrite(Datetime),
                /// Marks the end of a remote write operation. Only used when idempotence mode is off.
                EndRemoteWrite(EndRemoteWriteParameters),
                /// An invocation request arrived while the worker was busy
                PendingWorkerInvocation(PendingWorkerInvocationParameters),
                /// An update request arrived and will be applied as soon the worker restarts
                PendingUpdate(PendingUpdateParameters),
                /// An update was successfully applied
                SuccessfulUpdate(SuccessfulUpdateParameters),
                /// An update failed to be applied
                FailedUpdate(FailedUpdateParameters),
                /// Increased total linear memory size
                GrowMemory(GrowMemoryParameters),
                /// Created a resource instance
                CreateResource(CreateResourceParameters),
                /// Dropped a resource instance
                DropResource(DropResourceParameters),
                /// Adds additional information for a created resource instance
                DescribeResource(DescribeResourceParameters),
                /// The worker emitted a log message
                Log(LogParameters),
                /// The worker's has been restarted, forgetting all its history
                Restart(Datetime),
                /// Activates a plugin
                ActivatePlugin(ActivatePluginParameters),
                /// Deactivates a plugin
                DeactivatePlugin(DeactivatePluginParameters),
                /// Revert a worker to a previous state
                Revert(RevertParameters),
                /// Cancel a pending invocation
                CancelInvocation(CancelInvocationParameters),
                /// Start a new span in the invocation context
                StartSpan(StartSpanParameters),
                /// Finish an open span in the invocation context
                FinishSpan(FinishSpanParameters),
                /// Set an attribute on an open span in the invocation context
                SetSpanAttribute(SetSpanAttributeParameters),
            }
            impl ::core::fmt::Debug for OplogEntry {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        OplogEntry::Create(e) => {
                            f.debug_tuple("OplogEntry::Create").field(e).finish()
                        }
                        OplogEntry::ImportedFunctionInvoked(e) => {
                            f.debug_tuple("OplogEntry::ImportedFunctionInvoked")
                                .field(e)
                                .finish()
                        }
                        OplogEntry::ExportedFunctionInvoked(e) => {
                            f.debug_tuple("OplogEntry::ExportedFunctionInvoked")
                                .field(e)
                                .finish()
                        }
                        OplogEntry::ExportedFunctionCompleted(e) => {
                            f.debug_tuple("OplogEntry::ExportedFunctionCompleted")
                                .field(e)
                                .finish()
                        }
                        OplogEntry::Suspend(e) => {
                            f.debug_tuple("OplogEntry::Suspend").field(e).finish()
                        }
                        OplogEntry::Error(e) => {
                            f.debug_tuple("OplogEntry::Error").field(e).finish()
                        }
                        OplogEntry::NoOp(e) => {
                            f.debug_tuple("OplogEntry::NoOp").field(e).finish()
                        }
                        OplogEntry::Jump(e) => {
                            f.debug_tuple("OplogEntry::Jump").field(e).finish()
                        }
                        OplogEntry::Interrupted(e) => {
                            f.debug_tuple("OplogEntry::Interrupted").field(e).finish()
                        }
                        OplogEntry::Exited(e) => {
                            f.debug_tuple("OplogEntry::Exited").field(e).finish()
                        }
                        OplogEntry::ChangeRetryPolicy(e) => {
                            f.debug_tuple("OplogEntry::ChangeRetryPolicy")
                                .field(e)
                                .finish()
                        }
                        OplogEntry::BeginAtomicRegion(e) => {
                            f.debug_tuple("OplogEntry::BeginAtomicRegion")
                                .field(e)
                                .finish()
                        }
                        OplogEntry::EndAtomicRegion(e) => {
                            f.debug_tuple("OplogEntry::EndAtomicRegion")
                                .field(e)
                                .finish()
                        }
                        OplogEntry::BeginRemoteWrite(e) => {
                            f.debug_tuple("OplogEntry::BeginRemoteWrite")
                                .field(e)
                                .finish()
                        }
                        OplogEntry::EndRemoteWrite(e) => {
                            f.debug_tuple("OplogEntry::EndRemoteWrite").field(e).finish()
                        }
                        OplogEntry::PendingWorkerInvocation(e) => {
                            f.debug_tuple("OplogEntry::PendingWorkerInvocation")
                                .field(e)
                                .finish()
                        }
                        OplogEntry::PendingUpdate(e) => {
                            f.debug_tuple("OplogEntry::PendingUpdate").field(e).finish()
                        }
                        OplogEntry::SuccessfulUpdate(e) => {
                            f.debug_tuple("OplogEntry::SuccessfulUpdate")
                                .field(e)
                                .finish()
                        }
                        OplogEntry::FailedUpdate(e) => {
                            f.debug_tuple("OplogEntry::FailedUpdate").field(e).finish()
                        }
                        OplogEntry::GrowMemory(e) => {
                            f.debug_tuple("OplogEntry::GrowMemory").field(e).finish()
                        }
                        OplogEntry::CreateResource(e) => {
                            f.debug_tuple("OplogEntry::CreateResource").field(e).finish()
                        }
                        OplogEntry::DropResource(e) => {
                            f.debug_tuple("OplogEntry::DropResource").field(e).finish()
                        }
                        OplogEntry::DescribeResource(e) => {
                            f.debug_tuple("OplogEntry::DescribeResource")
                                .field(e)
                                .finish()
                        }
                        OplogEntry::Log(e) => {
                            f.debug_tuple("OplogEntry::Log").field(e).finish()
                        }
                        OplogEntry::Restart(e) => {
                            f.debug_tuple("OplogEntry::Restart").field(e).finish()
                        }
                        OplogEntry::ActivatePlugin(e) => {
                            f.debug_tuple("OplogEntry::ActivatePlugin").field(e).finish()
                        }
                        OplogEntry::DeactivatePlugin(e) => {
                            f.debug_tuple("OplogEntry::DeactivatePlugin")
                                .field(e)
                                .finish()
                        }
                        OplogEntry::Revert(e) => {
                            f.debug_tuple("OplogEntry::Revert").field(e).finish()
                        }
                        OplogEntry::CancelInvocation(e) => {
                            f.debug_tuple("OplogEntry::CancelInvocation")
                                .field(e)
                                .finish()
                        }
                        OplogEntry::StartSpan(e) => {
                            f.debug_tuple("OplogEntry::StartSpan").field(e).finish()
                        }
                        OplogEntry::FinishSpan(e) => {
                            f.debug_tuple("OplogEntry::FinishSpan").field(e).finish()
                        }
                        OplogEntry::SetSpanAttribute(e) => {
                            f.debug_tuple("OplogEntry::SetSpanAttribute")
                                .field(e)
                                .finish()
                        }
                    }
                }
            }
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct GetOplog {
                handle: _rt::Resource<GetOplog>,
            }
            impl GetOplog {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 GetOplog {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "golem:api/oplog@1.1.5")]
                        extern "C" {
                            #[link_name = "[resource-drop]get-oplog"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct SearchOplog {
                handle: _rt::Resource<SearchOplog>,
            }
            impl SearchOplog {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 SearchOplog {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "golem:api/oplog@1.1.5")]
                        extern "C" {
                            #[link_name = "[resource-drop]search-oplog"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            impl GetOplog {
                #[allow(unused_unsafe, clippy::all)]
                pub fn new(worker_id: &WorkerId, start: OplogIndex) -> Self {
                    unsafe {
                        let super::super::super::golem::api::host::WorkerId {
                            component_id: component_id0,
                            worker_name: worker_name0,
                        } = worker_id;
                        let super::super::super::golem::api::host::ComponentId {
                            uuid: uuid1,
                        } = component_id0;
                        let super::super::super::golem::api::host::Uuid {
                            high_bits: high_bits2,
                            low_bits: low_bits2,
                        } = uuid1;
                        let vec3 = worker_name0;
                        let ptr3 = vec3.as_ptr().cast::<u8>();
                        let len3 = vec3.len();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:api/oplog@1.1.5")]
                        extern "C" {
                            #[link_name = "[constructor]get-oplog"]
                            fn wit_import(
                                _: i64,
                                _: i64,
                                _: *mut u8,
                                _: usize,
                                _: i64,
                            ) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i64,
                            _: i64,
                            _: *mut u8,
                            _: usize,
                            _: i64,
                        ) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import(
                            _rt::as_i64(high_bits2),
                            _rt::as_i64(low_bits2),
                            ptr3.cast_mut(),
                            len3,
                            _rt::as_i64(start),
                        );
                        GetOplog::from_handle(ret as u32)
                    }
                }
            }
            impl GetOplog {
                #[allow(unused_unsafe, clippy::all)]
                pub fn get_next(&self) -> Option<_rt::Vec<OplogEntry>> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:api/oplog@1.1.5")]
                        extern "C" {
                            #[link_name = "[method]get-oplog.get-next"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<*mut u8>();
                                    let l3 = *ptr0.add(8).cast::<usize>();
                                    let base621 = l2;
                                    let len621 = l3;
                                    let mut result621 = _rt::Vec::with_capacity(len621);
                                    for i in 0..len621 {
                                        let base = base621.add(i * 136);
                                        let e621 = {
                                            let l4 = i32::from(*base.add(0).cast::<u8>());
                                            let v620 = match l4 {
                                                0 => {
                                                    let e620 = {
                                                        let l5 = *base.add(8).cast::<i64>();
                                                        let l6 = *base.add(16).cast::<i32>();
                                                        let l7 = *base.add(24).cast::<i64>();
                                                        let l8 = *base.add(32).cast::<i64>();
                                                        let l9 = *base.add(40).cast::<*mut u8>();
                                                        let l10 = *base.add(44).cast::<usize>();
                                                        let len11 = l10;
                                                        let bytes11 = _rt::Vec::from_raw_parts(
                                                            l9.cast(),
                                                            len11,
                                                            len11,
                                                        );
                                                        let l12 = *base.add(48).cast::<i64>();
                                                        let l13 = *base.add(56).cast::<*mut u8>();
                                                        let l14 = *base.add(60).cast::<usize>();
                                                        let base18 = l13;
                                                        let len18 = l14;
                                                        let mut result18 = _rt::Vec::with_capacity(len18);
                                                        for i in 0..len18 {
                                                            let base = base18.add(i * 8);
                                                            let e18 = {
                                                                let l15 = *base.add(0).cast::<*mut u8>();
                                                                let l16 = *base.add(4).cast::<usize>();
                                                                let len17 = l16;
                                                                let bytes17 = _rt::Vec::from_raw_parts(
                                                                    l15.cast(),
                                                                    len17,
                                                                    len17,
                                                                );
                                                                _rt::string_lift(bytes17)
                                                            };
                                                            result18.push(e18);
                                                        }
                                                        _rt::cabi_dealloc(base18, len18 * 8, 4);
                                                        let l19 = *base.add(64).cast::<*mut u8>();
                                                        let l20 = *base.add(68).cast::<usize>();
                                                        let base27 = l19;
                                                        let len27 = l20;
                                                        let mut result27 = _rt::Vec::with_capacity(len27);
                                                        for i in 0..len27 {
                                                            let base = base27.add(i * 16);
                                                            let e27 = {
                                                                let l21 = *base.add(0).cast::<*mut u8>();
                                                                let l22 = *base.add(4).cast::<usize>();
                                                                let len23 = l22;
                                                                let bytes23 = _rt::Vec::from_raw_parts(
                                                                    l21.cast(),
                                                                    len23,
                                                                    len23,
                                                                );
                                                                let l24 = *base.add(8).cast::<*mut u8>();
                                                                let l25 = *base.add(12).cast::<usize>();
                                                                let len26 = l25;
                                                                let bytes26 = _rt::Vec::from_raw_parts(
                                                                    l24.cast(),
                                                                    len26,
                                                                    len26,
                                                                );
                                                                (_rt::string_lift(bytes23), _rt::string_lift(bytes26))
                                                            };
                                                            result27.push(e27);
                                                        }
                                                        _rt::cabi_dealloc(base27, len27 * 16, 4);
                                                        let l28 = *base.add(72).cast::<*mut u8>();
                                                        let l29 = *base.add(76).cast::<usize>();
                                                        let len30 = l29;
                                                        let bytes30 = _rt::Vec::from_raw_parts(
                                                            l28.cast(),
                                                            len30,
                                                            len30,
                                                        );
                                                        let l31 = i32::from(*base.add(80).cast::<u8>());
                                                        let l37 = *base.add(112).cast::<i64>();
                                                        let l38 = *base.add(120).cast::<i64>();
                                                        let l39 = *base.add(128).cast::<*mut u8>();
                                                        let l40 = *base.add(132).cast::<usize>();
                                                        let base58 = l39;
                                                        let len58 = l40;
                                                        let mut result58 = _rt::Vec::with_capacity(len58);
                                                        for i in 0..len58 {
                                                            let base = base58.add(i * 40);
                                                            let e58 = {
                                                                let l41 = *base.add(0).cast::<i64>();
                                                                let l42 = *base.add(8).cast::<i64>();
                                                                let l43 = *base.add(16).cast::<*mut u8>();
                                                                let l44 = *base.add(20).cast::<usize>();
                                                                let len45 = l44;
                                                                let bytes45 = _rt::Vec::from_raw_parts(
                                                                    l43.cast(),
                                                                    len45,
                                                                    len45,
                                                                );
                                                                let l46 = *base.add(24).cast::<*mut u8>();
                                                                let l47 = *base.add(28).cast::<usize>();
                                                                let len48 = l47;
                                                                let bytes48 = _rt::Vec::from_raw_parts(
                                                                    l46.cast(),
                                                                    len48,
                                                                    len48,
                                                                );
                                                                let l49 = *base.add(32).cast::<*mut u8>();
                                                                let l50 = *base.add(36).cast::<usize>();
                                                                let base57 = l49;
                                                                let len57 = l50;
                                                                let mut result57 = _rt::Vec::with_capacity(len57);
                                                                for i in 0..len57 {
                                                                    let base = base57.add(i * 16);
                                                                    let e57 = {
                                                                        let l51 = *base.add(0).cast::<*mut u8>();
                                                                        let l52 = *base.add(4).cast::<usize>();
                                                                        let len53 = l52;
                                                                        let bytes53 = _rt::Vec::from_raw_parts(
                                                                            l51.cast(),
                                                                            len53,
                                                                            len53,
                                                                        );
                                                                        let l54 = *base.add(8).cast::<*mut u8>();
                                                                        let l55 = *base.add(12).cast::<usize>();
                                                                        let len56 = l55;
                                                                        let bytes56 = _rt::Vec::from_raw_parts(
                                                                            l54.cast(),
                                                                            len56,
                                                                            len56,
                                                                        );
                                                                        (_rt::string_lift(bytes53), _rt::string_lift(bytes56))
                                                                    };
                                                                    result57.push(e57);
                                                                }
                                                                _rt::cabi_dealloc(base57, len57 * 16, 4);
                                                                PluginInstallationDescription {
                                                                    installation_id: super::super::super::golem::api::host::Uuid {
                                                                        high_bits: l41 as u64,
                                                                        low_bits: l42 as u64,
                                                                    },
                                                                    name: _rt::string_lift(bytes45),
                                                                    version: _rt::string_lift(bytes48),
                                                                    parameters: result57,
                                                                }
                                                            };
                                                            result58.push(e58);
                                                        }
                                                        _rt::cabi_dealloc(base58, len58 * 40, 8);
                                                        CreateParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l5 as u64,
                                                                nanoseconds: l6 as u32,
                                                            },
                                                            worker_id: super::super::super::golem::api::host::WorkerId {
                                                                component_id: super::super::super::golem::api::host::ComponentId {
                                                                    uuid: super::super::super::golem::api::host::Uuid {
                                                                        high_bits: l7 as u64,
                                                                        low_bits: l8 as u64,
                                                                    },
                                                                },
                                                                worker_name: _rt::string_lift(bytes11),
                                                            },
                                                            component_version: l12 as u64,
                                                            args: result18,
                                                            env: result27,
                                                            account_id: super::super::super::golem::api::host::AccountId {
                                                                value: _rt::string_lift(bytes30),
                                                            },
                                                            parent: match l31 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l32 = *base.add(88).cast::<i64>();
                                                                        let l33 = *base.add(96).cast::<i64>();
                                                                        let l34 = *base.add(104).cast::<*mut u8>();
                                                                        let l35 = *base.add(108).cast::<usize>();
                                                                        let len36 = l35;
                                                                        let bytes36 = _rt::Vec::from_raw_parts(
                                                                            l34.cast(),
                                                                            len36,
                                                                            len36,
                                                                        );
                                                                        super::super::super::golem::api::host::WorkerId {
                                                                            component_id: super::super::super::golem::api::host::ComponentId {
                                                                                uuid: super::super::super::golem::api::host::Uuid {
                                                                                    high_bits: l32 as u64,
                                                                                    low_bits: l33 as u64,
                                                                                },
                                                                            },
                                                                            worker_name: _rt::string_lift(bytes36),
                                                                        }
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                            component_size: l37 as u64,
                                                            initial_total_linear_memory_size: l38 as u64,
                                                            initial_active_plugins: result58,
                                                        }
                                                    };
                                                    OplogEntry::Create(e620)
                                                }
                                                1 => {
                                                    let e620 = {
                                                        let l59 = *base.add(8).cast::<i64>();
                                                        let l60 = *base.add(16).cast::<i32>();
                                                        let l61 = *base.add(24).cast::<*mut u8>();
                                                        let l62 = *base.add(28).cast::<usize>();
                                                        let len63 = l62;
                                                        let bytes63 = _rt::Vec::from_raw_parts(
                                                            l61.cast(),
                                                            len63,
                                                            len63,
                                                        );
                                                        let l64 = *base.add(32).cast::<*mut u8>();
                                                        let l65 = *base.add(36).cast::<usize>();
                                                        let base111 = l64;
                                                        let len111 = l65;
                                                        let mut result111 = _rt::Vec::with_capacity(len111);
                                                        for i in 0..len111 {
                                                            let base = base111.add(i * 24);
                                                            let e111 = {
                                                                let l66 = i32::from(*base.add(0).cast::<u8>());
                                                                use super::super::super::golem::rpc::types::WitNode as V110;
                                                                let v110 = match l66 {
                                                                    0 => {
                                                                        let e110 = {
                                                                            let l67 = *base.add(8).cast::<*mut u8>();
                                                                            let l68 = *base.add(12).cast::<usize>();
                                                                            let len69 = l68;
                                                                            _rt::Vec::from_raw_parts(l67.cast(), len69, len69)
                                                                        };
                                                                        V110::RecordValue(e110)
                                                                    }
                                                                    1 => {
                                                                        let e110 = {
                                                                            let l70 = *base.add(8).cast::<i32>();
                                                                            let l71 = i32::from(*base.add(12).cast::<u8>());
                                                                            (
                                                                                l70 as u32,
                                                                                match l71 {
                                                                                    0 => None,
                                                                                    1 => {
                                                                                        let e = {
                                                                                            let l72 = *base.add(16).cast::<i32>();
                                                                                            l72
                                                                                        };
                                                                                        Some(e)
                                                                                    }
                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                },
                                                                            )
                                                                        };
                                                                        V110::VariantValue(e110)
                                                                    }
                                                                    2 => {
                                                                        let e110 = {
                                                                            let l73 = *base.add(8).cast::<i32>();
                                                                            l73 as u32
                                                                        };
                                                                        V110::EnumValue(e110)
                                                                    }
                                                                    3 => {
                                                                        let e110 = {
                                                                            let l74 = *base.add(8).cast::<*mut u8>();
                                                                            let l75 = *base.add(12).cast::<usize>();
                                                                            let base77 = l74;
                                                                            let len77 = l75;
                                                                            let mut result77 = _rt::Vec::with_capacity(len77);
                                                                            for i in 0..len77 {
                                                                                let base = base77.add(i * 1);
                                                                                let e77 = {
                                                                                    let l76 = i32::from(*base.add(0).cast::<u8>());
                                                                                    _rt::bool_lift(l76 as u8)
                                                                                };
                                                                                result77.push(e77);
                                                                            }
                                                                            _rt::cabi_dealloc(base77, len77 * 1, 1);
                                                                            result77
                                                                        };
                                                                        V110::FlagsValue(e110)
                                                                    }
                                                                    4 => {
                                                                        let e110 = {
                                                                            let l78 = *base.add(8).cast::<*mut u8>();
                                                                            let l79 = *base.add(12).cast::<usize>();
                                                                            let len80 = l79;
                                                                            _rt::Vec::from_raw_parts(l78.cast(), len80, len80)
                                                                        };
                                                                        V110::TupleValue(e110)
                                                                    }
                                                                    5 => {
                                                                        let e110 = {
                                                                            let l81 = *base.add(8).cast::<*mut u8>();
                                                                            let l82 = *base.add(12).cast::<usize>();
                                                                            let len83 = l82;
                                                                            _rt::Vec::from_raw_parts(l81.cast(), len83, len83)
                                                                        };
                                                                        V110::ListValue(e110)
                                                                    }
                                                                    6 => {
                                                                        let e110 = {
                                                                            let l84 = i32::from(*base.add(8).cast::<u8>());
                                                                            match l84 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l85 = *base.add(12).cast::<i32>();
                                                                                        l85
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            }
                                                                        };
                                                                        V110::OptionValue(e110)
                                                                    }
                                                                    7 => {
                                                                        let e110 = {
                                                                            let l86 = i32::from(*base.add(8).cast::<u8>());
                                                                            match l86 {
                                                                                0 => {
                                                                                    let e = {
                                                                                        let l87 = i32::from(*base.add(12).cast::<u8>());
                                                                                        match l87 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l88 = *base.add(16).cast::<i32>();
                                                                                                    l88
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        }
                                                                                    };
                                                                                    Ok(e)
                                                                                }
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l89 = i32::from(*base.add(12).cast::<u8>());
                                                                                        match l89 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l90 = *base.add(16).cast::<i32>();
                                                                                                    l90
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        }
                                                                                    };
                                                                                    Err(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            }
                                                                        };
                                                                        V110::ResultValue(e110)
                                                                    }
                                                                    8 => {
                                                                        let e110 = {
                                                                            let l91 = i32::from(*base.add(8).cast::<u8>());
                                                                            l91 as u8
                                                                        };
                                                                        V110::PrimU8(e110)
                                                                    }
                                                                    9 => {
                                                                        let e110 = {
                                                                            let l92 = i32::from(*base.add(8).cast::<u16>());
                                                                            l92 as u16
                                                                        };
                                                                        V110::PrimU16(e110)
                                                                    }
                                                                    10 => {
                                                                        let e110 = {
                                                                            let l93 = *base.add(8).cast::<i32>();
                                                                            l93 as u32
                                                                        };
                                                                        V110::PrimU32(e110)
                                                                    }
                                                                    11 => {
                                                                        let e110 = {
                                                                            let l94 = *base.add(8).cast::<i64>();
                                                                            l94 as u64
                                                                        };
                                                                        V110::PrimU64(e110)
                                                                    }
                                                                    12 => {
                                                                        let e110 = {
                                                                            let l95 = i32::from(*base.add(8).cast::<i8>());
                                                                            l95 as i8
                                                                        };
                                                                        V110::PrimS8(e110)
                                                                    }
                                                                    13 => {
                                                                        let e110 = {
                                                                            let l96 = i32::from(*base.add(8).cast::<i16>());
                                                                            l96 as i16
                                                                        };
                                                                        V110::PrimS16(e110)
                                                                    }
                                                                    14 => {
                                                                        let e110 = {
                                                                            let l97 = *base.add(8).cast::<i32>();
                                                                            l97
                                                                        };
                                                                        V110::PrimS32(e110)
                                                                    }
                                                                    15 => {
                                                                        let e110 = {
                                                                            let l98 = *base.add(8).cast::<i64>();
                                                                            l98
                                                                        };
                                                                        V110::PrimS64(e110)
                                                                    }
                                                                    16 => {
                                                                        let e110 = {
                                                                            let l99 = *base.add(8).cast::<f32>();
                                                                            l99
                                                                        };
                                                                        V110::PrimFloat32(e110)
                                                                    }
                                                                    17 => {
                                                                        let e110 = {
                                                                            let l100 = *base.add(8).cast::<f64>();
                                                                            l100
                                                                        };
                                                                        V110::PrimFloat64(e110)
                                                                    }
                                                                    18 => {
                                                                        let e110 = {
                                                                            let l101 = *base.add(8).cast::<i32>();
                                                                            _rt::char_lift(l101 as u32)
                                                                        };
                                                                        V110::PrimChar(e110)
                                                                    }
                                                                    19 => {
                                                                        let e110 = {
                                                                            let l102 = i32::from(*base.add(8).cast::<u8>());
                                                                            _rt::bool_lift(l102 as u8)
                                                                        };
                                                                        V110::PrimBool(e110)
                                                                    }
                                                                    20 => {
                                                                        let e110 = {
                                                                            let l103 = *base.add(8).cast::<*mut u8>();
                                                                            let l104 = *base.add(12).cast::<usize>();
                                                                            let len105 = l104;
                                                                            let bytes105 = _rt::Vec::from_raw_parts(
                                                                                l103.cast(),
                                                                                len105,
                                                                                len105,
                                                                            );
                                                                            _rt::string_lift(bytes105)
                                                                        };
                                                                        V110::PrimString(e110)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 21, "invalid enum discriminant");
                                                                        let e110 = {
                                                                            let l106 = *base.add(8).cast::<*mut u8>();
                                                                            let l107 = *base.add(12).cast::<usize>();
                                                                            let len108 = l107;
                                                                            let bytes108 = _rt::Vec::from_raw_parts(
                                                                                l106.cast(),
                                                                                len108,
                                                                                len108,
                                                                            );
                                                                            let l109 = *base.add(16).cast::<i64>();
                                                                            (
                                                                                super::super::super::golem::rpc::types::Uri {
                                                                                    value: _rt::string_lift(bytes108),
                                                                                },
                                                                                l109 as u64,
                                                                            )
                                                                        };
                                                                        V110::Handle(e110)
                                                                    }
                                                                };
                                                                v110
                                                            };
                                                            result111.push(e111);
                                                        }
                                                        _rt::cabi_dealloc(base111, len111 * 24, 8);
                                                        let l112 = *base.add(40).cast::<*mut u8>();
                                                        let l113 = *base.add(44).cast::<usize>();
                                                        let base159 = l112;
                                                        let len159 = l113;
                                                        let mut result159 = _rt::Vec::with_capacity(len159);
                                                        for i in 0..len159 {
                                                            let base = base159.add(i * 24);
                                                            let e159 = {
                                                                let l114 = i32::from(*base.add(0).cast::<u8>());
                                                                use super::super::super::golem::rpc::types::WitNode as V158;
                                                                let v158 = match l114 {
                                                                    0 => {
                                                                        let e158 = {
                                                                            let l115 = *base.add(8).cast::<*mut u8>();
                                                                            let l116 = *base.add(12).cast::<usize>();
                                                                            let len117 = l116;
                                                                            _rt::Vec::from_raw_parts(l115.cast(), len117, len117)
                                                                        };
                                                                        V158::RecordValue(e158)
                                                                    }
                                                                    1 => {
                                                                        let e158 = {
                                                                            let l118 = *base.add(8).cast::<i32>();
                                                                            let l119 = i32::from(*base.add(12).cast::<u8>());
                                                                            (
                                                                                l118 as u32,
                                                                                match l119 {
                                                                                    0 => None,
                                                                                    1 => {
                                                                                        let e = {
                                                                                            let l120 = *base.add(16).cast::<i32>();
                                                                                            l120
                                                                                        };
                                                                                        Some(e)
                                                                                    }
                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                },
                                                                            )
                                                                        };
                                                                        V158::VariantValue(e158)
                                                                    }
                                                                    2 => {
                                                                        let e158 = {
                                                                            let l121 = *base.add(8).cast::<i32>();
                                                                            l121 as u32
                                                                        };
                                                                        V158::EnumValue(e158)
                                                                    }
                                                                    3 => {
                                                                        let e158 = {
                                                                            let l122 = *base.add(8).cast::<*mut u8>();
                                                                            let l123 = *base.add(12).cast::<usize>();
                                                                            let base125 = l122;
                                                                            let len125 = l123;
                                                                            let mut result125 = _rt::Vec::with_capacity(len125);
                                                                            for i in 0..len125 {
                                                                                let base = base125.add(i * 1);
                                                                                let e125 = {
                                                                                    let l124 = i32::from(*base.add(0).cast::<u8>());
                                                                                    _rt::bool_lift(l124 as u8)
                                                                                };
                                                                                result125.push(e125);
                                                                            }
                                                                            _rt::cabi_dealloc(base125, len125 * 1, 1);
                                                                            result125
                                                                        };
                                                                        V158::FlagsValue(e158)
                                                                    }
                                                                    4 => {
                                                                        let e158 = {
                                                                            let l126 = *base.add(8).cast::<*mut u8>();
                                                                            let l127 = *base.add(12).cast::<usize>();
                                                                            let len128 = l127;
                                                                            _rt::Vec::from_raw_parts(l126.cast(), len128, len128)
                                                                        };
                                                                        V158::TupleValue(e158)
                                                                    }
                                                                    5 => {
                                                                        let e158 = {
                                                                            let l129 = *base.add(8).cast::<*mut u8>();
                                                                            let l130 = *base.add(12).cast::<usize>();
                                                                            let len131 = l130;
                                                                            _rt::Vec::from_raw_parts(l129.cast(), len131, len131)
                                                                        };
                                                                        V158::ListValue(e158)
                                                                    }
                                                                    6 => {
                                                                        let e158 = {
                                                                            let l132 = i32::from(*base.add(8).cast::<u8>());
                                                                            match l132 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l133 = *base.add(12).cast::<i32>();
                                                                                        l133
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            }
                                                                        };
                                                                        V158::OptionValue(e158)
                                                                    }
                                                                    7 => {
                                                                        let e158 = {
                                                                            let l134 = i32::from(*base.add(8).cast::<u8>());
                                                                            match l134 {
                                                                                0 => {
                                                                                    let e = {
                                                                                        let l135 = i32::from(*base.add(12).cast::<u8>());
                                                                                        match l135 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l136 = *base.add(16).cast::<i32>();
                                                                                                    l136
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        }
                                                                                    };
                                                                                    Ok(e)
                                                                                }
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l137 = i32::from(*base.add(12).cast::<u8>());
                                                                                        match l137 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l138 = *base.add(16).cast::<i32>();
                                                                                                    l138
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        }
                                                                                    };
                                                                                    Err(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            }
                                                                        };
                                                                        V158::ResultValue(e158)
                                                                    }
                                                                    8 => {
                                                                        let e158 = {
                                                                            let l139 = i32::from(*base.add(8).cast::<u8>());
                                                                            l139 as u8
                                                                        };
                                                                        V158::PrimU8(e158)
                                                                    }
                                                                    9 => {
                                                                        let e158 = {
                                                                            let l140 = i32::from(*base.add(8).cast::<u16>());
                                                                            l140 as u16
                                                                        };
                                                                        V158::PrimU16(e158)
                                                                    }
                                                                    10 => {
                                                                        let e158 = {
                                                                            let l141 = *base.add(8).cast::<i32>();
                                                                            l141 as u32
                                                                        };
                                                                        V158::PrimU32(e158)
                                                                    }
                                                                    11 => {
                                                                        let e158 = {
                                                                            let l142 = *base.add(8).cast::<i64>();
                                                                            l142 as u64
                                                                        };
                                                                        V158::PrimU64(e158)
                                                                    }
                                                                    12 => {
                                                                        let e158 = {
                                                                            let l143 = i32::from(*base.add(8).cast::<i8>());
                                                                            l143 as i8
                                                                        };
                                                                        V158::PrimS8(e158)
                                                                    }
                                                                    13 => {
                                                                        let e158 = {
                                                                            let l144 = i32::from(*base.add(8).cast::<i16>());
                                                                            l144 as i16
                                                                        };
                                                                        V158::PrimS16(e158)
                                                                    }
                                                                    14 => {
                                                                        let e158 = {
                                                                            let l145 = *base.add(8).cast::<i32>();
                                                                            l145
                                                                        };
                                                                        V158::PrimS32(e158)
                                                                    }
                                                                    15 => {
                                                                        let e158 = {
                                                                            let l146 = *base.add(8).cast::<i64>();
                                                                            l146
                                                                        };
                                                                        V158::PrimS64(e158)
                                                                    }
                                                                    16 => {
                                                                        let e158 = {
                                                                            let l147 = *base.add(8).cast::<f32>();
                                                                            l147
                                                                        };
                                                                        V158::PrimFloat32(e158)
                                                                    }
                                                                    17 => {
                                                                        let e158 = {
                                                                            let l148 = *base.add(8).cast::<f64>();
                                                                            l148
                                                                        };
                                                                        V158::PrimFloat64(e158)
                                                                    }
                                                                    18 => {
                                                                        let e158 = {
                                                                            let l149 = *base.add(8).cast::<i32>();
                                                                            _rt::char_lift(l149 as u32)
                                                                        };
                                                                        V158::PrimChar(e158)
                                                                    }
                                                                    19 => {
                                                                        let e158 = {
                                                                            let l150 = i32::from(*base.add(8).cast::<u8>());
                                                                            _rt::bool_lift(l150 as u8)
                                                                        };
                                                                        V158::PrimBool(e158)
                                                                    }
                                                                    20 => {
                                                                        let e158 = {
                                                                            let l151 = *base.add(8).cast::<*mut u8>();
                                                                            let l152 = *base.add(12).cast::<usize>();
                                                                            let len153 = l152;
                                                                            let bytes153 = _rt::Vec::from_raw_parts(
                                                                                l151.cast(),
                                                                                len153,
                                                                                len153,
                                                                            );
                                                                            _rt::string_lift(bytes153)
                                                                        };
                                                                        V158::PrimString(e158)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 21, "invalid enum discriminant");
                                                                        let e158 = {
                                                                            let l154 = *base.add(8).cast::<*mut u8>();
                                                                            let l155 = *base.add(12).cast::<usize>();
                                                                            let len156 = l155;
                                                                            let bytes156 = _rt::Vec::from_raw_parts(
                                                                                l154.cast(),
                                                                                len156,
                                                                                len156,
                                                                            );
                                                                            let l157 = *base.add(16).cast::<i64>();
                                                                            (
                                                                                super::super::super::golem::rpc::types::Uri {
                                                                                    value: _rt::string_lift(bytes156),
                                                                                },
                                                                                l157 as u64,
                                                                            )
                                                                        };
                                                                        V158::Handle(e158)
                                                                    }
                                                                };
                                                                v158
                                                            };
                                                            result159.push(e159);
                                                        }
                                                        _rt::cabi_dealloc(base159, len159 * 24, 8);
                                                        let l160 = i32::from(*base.add(48).cast::<u8>());
                                                        let v163 = match l160 {
                                                            0 => WrappedFunctionType::ReadLocal,
                                                            1 => WrappedFunctionType::WriteLocal,
                                                            2 => WrappedFunctionType::ReadRemote,
                                                            3 => WrappedFunctionType::WriteRemote,
                                                            n => {
                                                                debug_assert_eq!(n, 4, "invalid enum discriminant");
                                                                let e163 = {
                                                                    let l161 = i32::from(*base.add(56).cast::<u8>());
                                                                    match l161 {
                                                                        0 => None,
                                                                        1 => {
                                                                            let e = {
                                                                                let l162 = *base.add(64).cast::<i64>();
                                                                                l162 as u64
                                                                            };
                                                                            Some(e)
                                                                        }
                                                                        _ => _rt::invalid_enum_discriminant(),
                                                                    }
                                                                };
                                                                WrappedFunctionType::WriteRemoteBatched(e163)
                                                            }
                                                        };
                                                        ImportedFunctionInvokedParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l59 as u64,
                                                                nanoseconds: l60 as u32,
                                                            },
                                                            function_name: _rt::string_lift(bytes63),
                                                            request: super::super::super::golem::rpc::types::WitValue {
                                                                nodes: result111,
                                                            },
                                                            response: super::super::super::golem::rpc::types::WitValue {
                                                                nodes: result159,
                                                            },
                                                            wrapped_function_type: v163,
                                                        }
                                                    };
                                                    OplogEntry::ImportedFunctionInvoked(e620)
                                                }
                                                2 => {
                                                    let e620 = {
                                                        let l164 = *base.add(8).cast::<i64>();
                                                        let l165 = *base.add(16).cast::<i32>();
                                                        let l166 = *base.add(24).cast::<*mut u8>();
                                                        let l167 = *base.add(28).cast::<usize>();
                                                        let len168 = l167;
                                                        let bytes168 = _rt::Vec::from_raw_parts(
                                                            l166.cast(),
                                                            len168,
                                                            len168,
                                                        );
                                                        let l169 = *base.add(32).cast::<*mut u8>();
                                                        let l170 = *base.add(36).cast::<usize>();
                                                        let base219 = l169;
                                                        let len219 = l170;
                                                        let mut result219 = _rt::Vec::with_capacity(len219);
                                                        for i in 0..len219 {
                                                            let base = base219.add(i * 8);
                                                            let e219 = {
                                                                let l171 = *base.add(0).cast::<*mut u8>();
                                                                let l172 = *base.add(4).cast::<usize>();
                                                                let base218 = l171;
                                                                let len218 = l172;
                                                                let mut result218 = _rt::Vec::with_capacity(len218);
                                                                for i in 0..len218 {
                                                                    let base = base218.add(i * 24);
                                                                    let e218 = {
                                                                        let l173 = i32::from(*base.add(0).cast::<u8>());
                                                                        use super::super::super::golem::rpc::types::WitNode as V217;
                                                                        let v217 = match l173 {
                                                                            0 => {
                                                                                let e217 = {
                                                                                    let l174 = *base.add(8).cast::<*mut u8>();
                                                                                    let l175 = *base.add(12).cast::<usize>();
                                                                                    let len176 = l175;
                                                                                    _rt::Vec::from_raw_parts(l174.cast(), len176, len176)
                                                                                };
                                                                                V217::RecordValue(e217)
                                                                            }
                                                                            1 => {
                                                                                let e217 = {
                                                                                    let l177 = *base.add(8).cast::<i32>();
                                                                                    let l178 = i32::from(*base.add(12).cast::<u8>());
                                                                                    (
                                                                                        l177 as u32,
                                                                                        match l178 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l179 = *base.add(16).cast::<i32>();
                                                                                                    l179
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        },
                                                                                    )
                                                                                };
                                                                                V217::VariantValue(e217)
                                                                            }
                                                                            2 => {
                                                                                let e217 = {
                                                                                    let l180 = *base.add(8).cast::<i32>();
                                                                                    l180 as u32
                                                                                };
                                                                                V217::EnumValue(e217)
                                                                            }
                                                                            3 => {
                                                                                let e217 = {
                                                                                    let l181 = *base.add(8).cast::<*mut u8>();
                                                                                    let l182 = *base.add(12).cast::<usize>();
                                                                                    let base184 = l181;
                                                                                    let len184 = l182;
                                                                                    let mut result184 = _rt::Vec::with_capacity(len184);
                                                                                    for i in 0..len184 {
                                                                                        let base = base184.add(i * 1);
                                                                                        let e184 = {
                                                                                            let l183 = i32::from(*base.add(0).cast::<u8>());
                                                                                            _rt::bool_lift(l183 as u8)
                                                                                        };
                                                                                        result184.push(e184);
                                                                                    }
                                                                                    _rt::cabi_dealloc(base184, len184 * 1, 1);
                                                                                    result184
                                                                                };
                                                                                V217::FlagsValue(e217)
                                                                            }
                                                                            4 => {
                                                                                let e217 = {
                                                                                    let l185 = *base.add(8).cast::<*mut u8>();
                                                                                    let l186 = *base.add(12).cast::<usize>();
                                                                                    let len187 = l186;
                                                                                    _rt::Vec::from_raw_parts(l185.cast(), len187, len187)
                                                                                };
                                                                                V217::TupleValue(e217)
                                                                            }
                                                                            5 => {
                                                                                let e217 = {
                                                                                    let l188 = *base.add(8).cast::<*mut u8>();
                                                                                    let l189 = *base.add(12).cast::<usize>();
                                                                                    let len190 = l189;
                                                                                    _rt::Vec::from_raw_parts(l188.cast(), len190, len190)
                                                                                };
                                                                                V217::ListValue(e217)
                                                                            }
                                                                            6 => {
                                                                                let e217 = {
                                                                                    let l191 = i32::from(*base.add(8).cast::<u8>());
                                                                                    match l191 {
                                                                                        0 => None,
                                                                                        1 => {
                                                                                            let e = {
                                                                                                let l192 = *base.add(12).cast::<i32>();
                                                                                                l192
                                                                                            };
                                                                                            Some(e)
                                                                                        }
                                                                                        _ => _rt::invalid_enum_discriminant(),
                                                                                    }
                                                                                };
                                                                                V217::OptionValue(e217)
                                                                            }
                                                                            7 => {
                                                                                let e217 = {
                                                                                    let l193 = i32::from(*base.add(8).cast::<u8>());
                                                                                    match l193 {
                                                                                        0 => {
                                                                                            let e = {
                                                                                                let l194 = i32::from(*base.add(12).cast::<u8>());
                                                                                                match l194 {
                                                                                                    0 => None,
                                                                                                    1 => {
                                                                                                        let e = {
                                                                                                            let l195 = *base.add(16).cast::<i32>();
                                                                                                            l195
                                                                                                        };
                                                                                                        Some(e)
                                                                                                    }
                                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                                }
                                                                                            };
                                                                                            Ok(e)
                                                                                        }
                                                                                        1 => {
                                                                                            let e = {
                                                                                                let l196 = i32::from(*base.add(12).cast::<u8>());
                                                                                                match l196 {
                                                                                                    0 => None,
                                                                                                    1 => {
                                                                                                        let e = {
                                                                                                            let l197 = *base.add(16).cast::<i32>();
                                                                                                            l197
                                                                                                        };
                                                                                                        Some(e)
                                                                                                    }
                                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                                }
                                                                                            };
                                                                                            Err(e)
                                                                                        }
                                                                                        _ => _rt::invalid_enum_discriminant(),
                                                                                    }
                                                                                };
                                                                                V217::ResultValue(e217)
                                                                            }
                                                                            8 => {
                                                                                let e217 = {
                                                                                    let l198 = i32::from(*base.add(8).cast::<u8>());
                                                                                    l198 as u8
                                                                                };
                                                                                V217::PrimU8(e217)
                                                                            }
                                                                            9 => {
                                                                                let e217 = {
                                                                                    let l199 = i32::from(*base.add(8).cast::<u16>());
                                                                                    l199 as u16
                                                                                };
                                                                                V217::PrimU16(e217)
                                                                            }
                                                                            10 => {
                                                                                let e217 = {
                                                                                    let l200 = *base.add(8).cast::<i32>();
                                                                                    l200 as u32
                                                                                };
                                                                                V217::PrimU32(e217)
                                                                            }
                                                                            11 => {
                                                                                let e217 = {
                                                                                    let l201 = *base.add(8).cast::<i64>();
                                                                                    l201 as u64
                                                                                };
                                                                                V217::PrimU64(e217)
                                                                            }
                                                                            12 => {
                                                                                let e217 = {
                                                                                    let l202 = i32::from(*base.add(8).cast::<i8>());
                                                                                    l202 as i8
                                                                                };
                                                                                V217::PrimS8(e217)
                                                                            }
                                                                            13 => {
                                                                                let e217 = {
                                                                                    let l203 = i32::from(*base.add(8).cast::<i16>());
                                                                                    l203 as i16
                                                                                };
                                                                                V217::PrimS16(e217)
                                                                            }
                                                                            14 => {
                                                                                let e217 = {
                                                                                    let l204 = *base.add(8).cast::<i32>();
                                                                                    l204
                                                                                };
                                                                                V217::PrimS32(e217)
                                                                            }
                                                                            15 => {
                                                                                let e217 = {
                                                                                    let l205 = *base.add(8).cast::<i64>();
                                                                                    l205
                                                                                };
                                                                                V217::PrimS64(e217)
                                                                            }
                                                                            16 => {
                                                                                let e217 = {
                                                                                    let l206 = *base.add(8).cast::<f32>();
                                                                                    l206
                                                                                };
                                                                                V217::PrimFloat32(e217)
                                                                            }
                                                                            17 => {
                                                                                let e217 = {
                                                                                    let l207 = *base.add(8).cast::<f64>();
                                                                                    l207
                                                                                };
                                                                                V217::PrimFloat64(e217)
                                                                            }
                                                                            18 => {
                                                                                let e217 = {
                                                                                    let l208 = *base.add(8).cast::<i32>();
                                                                                    _rt::char_lift(l208 as u32)
                                                                                };
                                                                                V217::PrimChar(e217)
                                                                            }
                                                                            19 => {
                                                                                let e217 = {
                                                                                    let l209 = i32::from(*base.add(8).cast::<u8>());
                                                                                    _rt::bool_lift(l209 as u8)
                                                                                };
                                                                                V217::PrimBool(e217)
                                                                            }
                                                                            20 => {
                                                                                let e217 = {
                                                                                    let l210 = *base.add(8).cast::<*mut u8>();
                                                                                    let l211 = *base.add(12).cast::<usize>();
                                                                                    let len212 = l211;
                                                                                    let bytes212 = _rt::Vec::from_raw_parts(
                                                                                        l210.cast(),
                                                                                        len212,
                                                                                        len212,
                                                                                    );
                                                                                    _rt::string_lift(bytes212)
                                                                                };
                                                                                V217::PrimString(e217)
                                                                            }
                                                                            n => {
                                                                                debug_assert_eq!(n, 21, "invalid enum discriminant");
                                                                                let e217 = {
                                                                                    let l213 = *base.add(8).cast::<*mut u8>();
                                                                                    let l214 = *base.add(12).cast::<usize>();
                                                                                    let len215 = l214;
                                                                                    let bytes215 = _rt::Vec::from_raw_parts(
                                                                                        l213.cast(),
                                                                                        len215,
                                                                                        len215,
                                                                                    );
                                                                                    let l216 = *base.add(16).cast::<i64>();
                                                                                    (
                                                                                        super::super::super::golem::rpc::types::Uri {
                                                                                            value: _rt::string_lift(bytes215),
                                                                                        },
                                                                                        l216 as u64,
                                                                                    )
                                                                                };
                                                                                V217::Handle(e217)
                                                                            }
                                                                        };
                                                                        v217
                                                                    };
                                                                    result218.push(e218);
                                                                }
                                                                _rt::cabi_dealloc(base218, len218 * 24, 8);
                                                                super::super::super::golem::rpc::types::WitValue {
                                                                    nodes: result218,
                                                                }
                                                            };
                                                            result219.push(e219);
                                                        }
                                                        _rt::cabi_dealloc(base219, len219 * 8, 4);
                                                        let l220 = *base.add(40).cast::<*mut u8>();
                                                        let l221 = *base.add(44).cast::<usize>();
                                                        let len222 = l221;
                                                        let bytes222 = _rt::Vec::from_raw_parts(
                                                            l220.cast(),
                                                            len222,
                                                            len222,
                                                        );
                                                        let l223 = *base.add(48).cast::<*mut u8>();
                                                        let l224 = *base.add(52).cast::<usize>();
                                                        let len225 = l224;
                                                        let bytes225 = _rt::Vec::from_raw_parts(
                                                            l223.cast(),
                                                            len225,
                                                            len225,
                                                        );
                                                        let l226 = *base.add(56).cast::<*mut u8>();
                                                        let l227 = *base.add(60).cast::<usize>();
                                                        let base231 = l226;
                                                        let len231 = l227;
                                                        let mut result231 = _rt::Vec::with_capacity(len231);
                                                        for i in 0..len231 {
                                                            let base = base231.add(i * 8);
                                                            let e231 = {
                                                                let l228 = *base.add(0).cast::<*mut u8>();
                                                                let l229 = *base.add(4).cast::<usize>();
                                                                let len230 = l229;
                                                                let bytes230 = _rt::Vec::from_raw_parts(
                                                                    l228.cast(),
                                                                    len230,
                                                                    len230,
                                                                );
                                                                _rt::string_lift(bytes230)
                                                            };
                                                            result231.push(e231);
                                                        }
                                                        _rt::cabi_dealloc(base231, len231 * 8, 4);
                                                        let l232 = *base.add(64).cast::<*mut u8>();
                                                        let l233 = *base.add(68).cast::<usize>();
                                                        let base265 = l232;
                                                        let len265 = l233;
                                                        let mut result265 = _rt::Vec::with_capacity(len265);
                                                        for i in 0..len265 {
                                                            let base = base265.add(i * 8);
                                                            let e265 = {
                                                                let l234 = *base.add(0).cast::<*mut u8>();
                                                                let l235 = *base.add(4).cast::<usize>();
                                                                let base264 = l234;
                                                                let len264 = l235;
                                                                let mut result264 = _rt::Vec::with_capacity(len264);
                                                                for i in 0..len264 {
                                                                    let base = base264.add(i * 80);
                                                                    let e264 = {
                                                                        let l236 = i32::from(*base.add(0).cast::<u8>());
                                                                        let v263 = match l236 {
                                                                            0 => {
                                                                                let e263 = {
                                                                                    let l237 = *base.add(8).cast::<*mut u8>();
                                                                                    let l238 = *base.add(12).cast::<usize>();
                                                                                    let len239 = l238;
                                                                                    let bytes239 = _rt::Vec::from_raw_parts(
                                                                                        l237.cast(),
                                                                                        len239,
                                                                                        len239,
                                                                                    );
                                                                                    let l240 = *base.add(16).cast::<i64>();
                                                                                    let l241 = *base.add(24).cast::<i32>();
                                                                                    let l242 = i32::from(*base.add(32).cast::<u8>());
                                                                                    let l246 = i32::from(*base.add(48).cast::<u8>());
                                                                                    let l248 = *base.add(64).cast::<*mut u8>();
                                                                                    let l249 = *base.add(68).cast::<usize>();
                                                                                    let base258 = l248;
                                                                                    let len258 = l249;
                                                                                    let mut result258 = _rt::Vec::with_capacity(len258);
                                                                                    for i in 0..len258 {
                                                                                        let base = base258.add(i * 20);
                                                                                        let e258 = {
                                                                                            let l250 = *base.add(0).cast::<*mut u8>();
                                                                                            let l251 = *base.add(4).cast::<usize>();
                                                                                            let len252 = l251;
                                                                                            let bytes252 = _rt::Vec::from_raw_parts(
                                                                                                l250.cast(),
                                                                                                len252,
                                                                                                len252,
                                                                                            );
                                                                                            let l253 = i32::from(*base.add(8).cast::<u8>());
                                                                                            use super::super::super::golem::api::context::AttributeValue as V257;
                                                                                            let v257 = match l253 {
                                                                                                n => {
                                                                                                    debug_assert_eq!(n, 0, "invalid enum discriminant");
                                                                                                    let e257 = {
                                                                                                        let l254 = *base.add(12).cast::<*mut u8>();
                                                                                                        let l255 = *base.add(16).cast::<usize>();
                                                                                                        let len256 = l255;
                                                                                                        let bytes256 = _rt::Vec::from_raw_parts(
                                                                                                            l254.cast(),
                                                                                                            len256,
                                                                                                            len256,
                                                                                                        );
                                                                                                        _rt::string_lift(bytes256)
                                                                                                    };
                                                                                                    V257::String(e257)
                                                                                                }
                                                                                            };
                                                                                            super::super::super::golem::api::context::Attribute {
                                                                                                key: _rt::string_lift(bytes252),
                                                                                                value: v257,
                                                                                            }
                                                                                        };
                                                                                        result258.push(e258);
                                                                                    }
                                                                                    _rt::cabi_dealloc(base258, len258 * 20, 4);
                                                                                    let l259 = i32::from(*base.add(72).cast::<u8>());
                                                                                    LocalSpanData {
                                                                                        span_id: _rt::string_lift(bytes239),
                                                                                        start: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                                            seconds: l240 as u64,
                                                                                            nanoseconds: l241 as u32,
                                                                                        },
                                                                                        parent: match l242 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l243 = *base.add(36).cast::<*mut u8>();
                                                                                                    let l244 = *base.add(40).cast::<usize>();
                                                                                                    let len245 = l244;
                                                                                                    let bytes245 = _rt::Vec::from_raw_parts(
                                                                                                        l243.cast(),
                                                                                                        len245,
                                                                                                        len245,
                                                                                                    );
                                                                                                    _rt::string_lift(bytes245)
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        },
                                                                                        linked_context: match l246 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l247 = *base.add(56).cast::<i64>();
                                                                                                    l247 as u64
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        },
                                                                                        attributes: result258,
                                                                                        inherited: _rt::bool_lift(l259 as u8),
                                                                                    }
                                                                                };
                                                                                SpanData::LocalSpan(e263)
                                                                            }
                                                                            n => {
                                                                                debug_assert_eq!(n, 1, "invalid enum discriminant");
                                                                                let e263 = {
                                                                                    let l260 = *base.add(8).cast::<*mut u8>();
                                                                                    let l261 = *base.add(12).cast::<usize>();
                                                                                    let len262 = l261;
                                                                                    let bytes262 = _rt::Vec::from_raw_parts(
                                                                                        l260.cast(),
                                                                                        len262,
                                                                                        len262,
                                                                                    );
                                                                                    ExternalSpanData {
                                                                                        span_id: _rt::string_lift(bytes262),
                                                                                    }
                                                                                };
                                                                                SpanData::ExternalSpan(e263)
                                                                            }
                                                                        };
                                                                        v263
                                                                    };
                                                                    result264.push(e264);
                                                                }
                                                                _rt::cabi_dealloc(base264, len264 * 80, 8);
                                                                result264
                                                            };
                                                            result265.push(e265);
                                                        }
                                                        _rt::cabi_dealloc(base265, len265 * 8, 4);
                                                        ExportedFunctionInvokedParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l164 as u64,
                                                                nanoseconds: l165 as u32,
                                                            },
                                                            function_name: _rt::string_lift(bytes168),
                                                            request: result219,
                                                            idempotency_key: _rt::string_lift(bytes222),
                                                            trace_id: _rt::string_lift(bytes225),
                                                            trace_states: result231,
                                                            invocation_context: result265,
                                                        }
                                                    };
                                                    OplogEntry::ExportedFunctionInvoked(e620)
                                                }
                                                3 => {
                                                    let e620 = {
                                                        let l266 = *base.add(8).cast::<i64>();
                                                        let l267 = *base.add(16).cast::<i32>();
                                                        let l268 = *base.add(24).cast::<*mut u8>();
                                                        let l269 = *base.add(28).cast::<usize>();
                                                        let base315 = l268;
                                                        let len315 = l269;
                                                        let mut result315 = _rt::Vec::with_capacity(len315);
                                                        for i in 0..len315 {
                                                            let base = base315.add(i * 24);
                                                            let e315 = {
                                                                let l270 = i32::from(*base.add(0).cast::<u8>());
                                                                use super::super::super::golem::rpc::types::WitNode as V314;
                                                                let v314 = match l270 {
                                                                    0 => {
                                                                        let e314 = {
                                                                            let l271 = *base.add(8).cast::<*mut u8>();
                                                                            let l272 = *base.add(12).cast::<usize>();
                                                                            let len273 = l272;
                                                                            _rt::Vec::from_raw_parts(l271.cast(), len273, len273)
                                                                        };
                                                                        V314::RecordValue(e314)
                                                                    }
                                                                    1 => {
                                                                        let e314 = {
                                                                            let l274 = *base.add(8).cast::<i32>();
                                                                            let l275 = i32::from(*base.add(12).cast::<u8>());
                                                                            (
                                                                                l274 as u32,
                                                                                match l275 {
                                                                                    0 => None,
                                                                                    1 => {
                                                                                        let e = {
                                                                                            let l276 = *base.add(16).cast::<i32>();
                                                                                            l276
                                                                                        };
                                                                                        Some(e)
                                                                                    }
                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                },
                                                                            )
                                                                        };
                                                                        V314::VariantValue(e314)
                                                                    }
                                                                    2 => {
                                                                        let e314 = {
                                                                            let l277 = *base.add(8).cast::<i32>();
                                                                            l277 as u32
                                                                        };
                                                                        V314::EnumValue(e314)
                                                                    }
                                                                    3 => {
                                                                        let e314 = {
                                                                            let l278 = *base.add(8).cast::<*mut u8>();
                                                                            let l279 = *base.add(12).cast::<usize>();
                                                                            let base281 = l278;
                                                                            let len281 = l279;
                                                                            let mut result281 = _rt::Vec::with_capacity(len281);
                                                                            for i in 0..len281 {
                                                                                let base = base281.add(i * 1);
                                                                                let e281 = {
                                                                                    let l280 = i32::from(*base.add(0).cast::<u8>());
                                                                                    _rt::bool_lift(l280 as u8)
                                                                                };
                                                                                result281.push(e281);
                                                                            }
                                                                            _rt::cabi_dealloc(base281, len281 * 1, 1);
                                                                            result281
                                                                        };
                                                                        V314::FlagsValue(e314)
                                                                    }
                                                                    4 => {
                                                                        let e314 = {
                                                                            let l282 = *base.add(8).cast::<*mut u8>();
                                                                            let l283 = *base.add(12).cast::<usize>();
                                                                            let len284 = l283;
                                                                            _rt::Vec::from_raw_parts(l282.cast(), len284, len284)
                                                                        };
                                                                        V314::TupleValue(e314)
                                                                    }
                                                                    5 => {
                                                                        let e314 = {
                                                                            let l285 = *base.add(8).cast::<*mut u8>();
                                                                            let l286 = *base.add(12).cast::<usize>();
                                                                            let len287 = l286;
                                                                            _rt::Vec::from_raw_parts(l285.cast(), len287, len287)
                                                                        };
                                                                        V314::ListValue(e314)
                                                                    }
                                                                    6 => {
                                                                        let e314 = {
                                                                            let l288 = i32::from(*base.add(8).cast::<u8>());
                                                                            match l288 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l289 = *base.add(12).cast::<i32>();
                                                                                        l289
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            }
                                                                        };
                                                                        V314::OptionValue(e314)
                                                                    }
                                                                    7 => {
                                                                        let e314 = {
                                                                            let l290 = i32::from(*base.add(8).cast::<u8>());
                                                                            match l290 {
                                                                                0 => {
                                                                                    let e = {
                                                                                        let l291 = i32::from(*base.add(12).cast::<u8>());
                                                                                        match l291 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l292 = *base.add(16).cast::<i32>();
                                                                                                    l292
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        }
                                                                                    };
                                                                                    Ok(e)
                                                                                }
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l293 = i32::from(*base.add(12).cast::<u8>());
                                                                                        match l293 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l294 = *base.add(16).cast::<i32>();
                                                                                                    l294
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        }
                                                                                    };
                                                                                    Err(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            }
                                                                        };
                                                                        V314::ResultValue(e314)
                                                                    }
                                                                    8 => {
                                                                        let e314 = {
                                                                            let l295 = i32::from(*base.add(8).cast::<u8>());
                                                                            l295 as u8
                                                                        };
                                                                        V314::PrimU8(e314)
                                                                    }
                                                                    9 => {
                                                                        let e314 = {
                                                                            let l296 = i32::from(*base.add(8).cast::<u16>());
                                                                            l296 as u16
                                                                        };
                                                                        V314::PrimU16(e314)
                                                                    }
                                                                    10 => {
                                                                        let e314 = {
                                                                            let l297 = *base.add(8).cast::<i32>();
                                                                            l297 as u32
                                                                        };
                                                                        V314::PrimU32(e314)
                                                                    }
                                                                    11 => {
                                                                        let e314 = {
                                                                            let l298 = *base.add(8).cast::<i64>();
                                                                            l298 as u64
                                                                        };
                                                                        V314::PrimU64(e314)
                                                                    }
                                                                    12 => {
                                                                        let e314 = {
                                                                            let l299 = i32::from(*base.add(8).cast::<i8>());
                                                                            l299 as i8
                                                                        };
                                                                        V314::PrimS8(e314)
                                                                    }
                                                                    13 => {
                                                                        let e314 = {
                                                                            let l300 = i32::from(*base.add(8).cast::<i16>());
                                                                            l300 as i16
                                                                        };
                                                                        V314::PrimS16(e314)
                                                                    }
                                                                    14 => {
                                                                        let e314 = {
                                                                            let l301 = *base.add(8).cast::<i32>();
                                                                            l301
                                                                        };
                                                                        V314::PrimS32(e314)
                                                                    }
                                                                    15 => {
                                                                        let e314 = {
                                                                            let l302 = *base.add(8).cast::<i64>();
                                                                            l302
                                                                        };
                                                                        V314::PrimS64(e314)
                                                                    }
                                                                    16 => {
                                                                        let e314 = {
                                                                            let l303 = *base.add(8).cast::<f32>();
                                                                            l303
                                                                        };
                                                                        V314::PrimFloat32(e314)
                                                                    }
                                                                    17 => {
                                                                        let e314 = {
                                                                            let l304 = *base.add(8).cast::<f64>();
                                                                            l304
                                                                        };
                                                                        V314::PrimFloat64(e314)
                                                                    }
                                                                    18 => {
                                                                        let e314 = {
                                                                            let l305 = *base.add(8).cast::<i32>();
                                                                            _rt::char_lift(l305 as u32)
                                                                        };
                                                                        V314::PrimChar(e314)
                                                                    }
                                                                    19 => {
                                                                        let e314 = {
                                                                            let l306 = i32::from(*base.add(8).cast::<u8>());
                                                                            _rt::bool_lift(l306 as u8)
                                                                        };
                                                                        V314::PrimBool(e314)
                                                                    }
                                                                    20 => {
                                                                        let e314 = {
                                                                            let l307 = *base.add(8).cast::<*mut u8>();
                                                                            let l308 = *base.add(12).cast::<usize>();
                                                                            let len309 = l308;
                                                                            let bytes309 = _rt::Vec::from_raw_parts(
                                                                                l307.cast(),
                                                                                len309,
                                                                                len309,
                                                                            );
                                                                            _rt::string_lift(bytes309)
                                                                        };
                                                                        V314::PrimString(e314)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 21, "invalid enum discriminant");
                                                                        let e314 = {
                                                                            let l310 = *base.add(8).cast::<*mut u8>();
                                                                            let l311 = *base.add(12).cast::<usize>();
                                                                            let len312 = l311;
                                                                            let bytes312 = _rt::Vec::from_raw_parts(
                                                                                l310.cast(),
                                                                                len312,
                                                                                len312,
                                                                            );
                                                                            let l313 = *base.add(16).cast::<i64>();
                                                                            (
                                                                                super::super::super::golem::rpc::types::Uri {
                                                                                    value: _rt::string_lift(bytes312),
                                                                                },
                                                                                l313 as u64,
                                                                            )
                                                                        };
                                                                        V314::Handle(e314)
                                                                    }
                                                                };
                                                                v314
                                                            };
                                                            result315.push(e315);
                                                        }
                                                        _rt::cabi_dealloc(base315, len315 * 24, 8);
                                                        let l316 = *base.add(32).cast::<i64>();
                                                        ExportedFunctionCompletedParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l266 as u64,
                                                                nanoseconds: l267 as u32,
                                                            },
                                                            response: super::super::super::golem::rpc::types::WitValue {
                                                                nodes: result315,
                                                            },
                                                            consumed_fuel: l316,
                                                        }
                                                    };
                                                    OplogEntry::ExportedFunctionCompleted(e620)
                                                }
                                                4 => {
                                                    let e620 = {
                                                        let l317 = *base.add(8).cast::<i64>();
                                                        let l318 = *base.add(16).cast::<i32>();
                                                        super::super::super::wasi::clocks::wall_clock::Datetime {
                                                            seconds: l317 as u64,
                                                            nanoseconds: l318 as u32,
                                                        }
                                                    };
                                                    OplogEntry::Suspend(e620)
                                                }
                                                5 => {
                                                    let e620 = {
                                                        let l319 = *base.add(8).cast::<i64>();
                                                        let l320 = *base.add(16).cast::<i32>();
                                                        let l321 = *base.add(24).cast::<*mut u8>();
                                                        let l322 = *base.add(28).cast::<usize>();
                                                        let len323 = l322;
                                                        let bytes323 = _rt::Vec::from_raw_parts(
                                                            l321.cast(),
                                                            len323,
                                                            len323,
                                                        );
                                                        ErrorParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l319 as u64,
                                                                nanoseconds: l320 as u32,
                                                            },
                                                            error: _rt::string_lift(bytes323),
                                                        }
                                                    };
                                                    OplogEntry::Error(e620)
                                                }
                                                6 => {
                                                    let e620 = {
                                                        let l324 = *base.add(8).cast::<i64>();
                                                        let l325 = *base.add(16).cast::<i32>();
                                                        super::super::super::wasi::clocks::wall_clock::Datetime {
                                                            seconds: l324 as u64,
                                                            nanoseconds: l325 as u32,
                                                        }
                                                    };
                                                    OplogEntry::NoOp(e620)
                                                }
                                                7 => {
                                                    let e620 = {
                                                        let l326 = *base.add(8).cast::<i64>();
                                                        let l327 = *base.add(16).cast::<i32>();
                                                        let l328 = *base.add(24).cast::<i64>();
                                                        let l329 = *base.add(32).cast::<i64>();
                                                        JumpParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l326 as u64,
                                                                nanoseconds: l327 as u32,
                                                            },
                                                            start: l328 as u64,
                                                            end: l329 as u64,
                                                        }
                                                    };
                                                    OplogEntry::Jump(e620)
                                                }
                                                8 => {
                                                    let e620 = {
                                                        let l330 = *base.add(8).cast::<i64>();
                                                        let l331 = *base.add(16).cast::<i32>();
                                                        super::super::super::wasi::clocks::wall_clock::Datetime {
                                                            seconds: l330 as u64,
                                                            nanoseconds: l331 as u32,
                                                        }
                                                    };
                                                    OplogEntry::Interrupted(e620)
                                                }
                                                9 => {
                                                    let e620 = {
                                                        let l332 = *base.add(8).cast::<i64>();
                                                        let l333 = *base.add(16).cast::<i32>();
                                                        super::super::super::wasi::clocks::wall_clock::Datetime {
                                                            seconds: l332 as u64,
                                                            nanoseconds: l333 as u32,
                                                        }
                                                    };
                                                    OplogEntry::Exited(e620)
                                                }
                                                10 => {
                                                    let e620 = {
                                                        let l334 = *base.add(8).cast::<i64>();
                                                        let l335 = *base.add(16).cast::<i32>();
                                                        let l336 = *base.add(24).cast::<i32>();
                                                        let l337 = *base.add(32).cast::<i64>();
                                                        let l338 = *base.add(40).cast::<i64>();
                                                        let l339 = *base.add(48).cast::<f64>();
                                                        let l340 = i32::from(*base.add(56).cast::<u8>());
                                                        ChangeRetryPolicyParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l334 as u64,
                                                                nanoseconds: l335 as u32,
                                                            },
                                                            retry_policy: super::super::super::golem::api::host::RetryPolicy {
                                                                max_attempts: l336 as u32,
                                                                min_delay: l337 as u64,
                                                                max_delay: l338 as u64,
                                                                multiplier: l339,
                                                                max_jitter_factor: match l340 {
                                                                    0 => None,
                                                                    1 => {
                                                                        let e = {
                                                                            let l341 = *base.add(64).cast::<f64>();
                                                                            l341
                                                                        };
                                                                        Some(e)
                                                                    }
                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                },
                                                            },
                                                        }
                                                    };
                                                    OplogEntry::ChangeRetryPolicy(e620)
                                                }
                                                11 => {
                                                    let e620 = {
                                                        let l342 = *base.add(8).cast::<i64>();
                                                        let l343 = *base.add(16).cast::<i32>();
                                                        super::super::super::wasi::clocks::wall_clock::Datetime {
                                                            seconds: l342 as u64,
                                                            nanoseconds: l343 as u32,
                                                        }
                                                    };
                                                    OplogEntry::BeginAtomicRegion(e620)
                                                }
                                                12 => {
                                                    let e620 = {
                                                        let l344 = *base.add(8).cast::<i64>();
                                                        let l345 = *base.add(16).cast::<i32>();
                                                        let l346 = *base.add(24).cast::<i64>();
                                                        EndAtomicRegionParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l344 as u64,
                                                                nanoseconds: l345 as u32,
                                                            },
                                                            begin_index: l346 as u64,
                                                        }
                                                    };
                                                    OplogEntry::EndAtomicRegion(e620)
                                                }
                                                13 => {
                                                    let e620 = {
                                                        let l347 = *base.add(8).cast::<i64>();
                                                        let l348 = *base.add(16).cast::<i32>();
                                                        super::super::super::wasi::clocks::wall_clock::Datetime {
                                                            seconds: l347 as u64,
                                                            nanoseconds: l348 as u32,
                                                        }
                                                    };
                                                    OplogEntry::BeginRemoteWrite(e620)
                                                }
                                                14 => {
                                                    let e620 = {
                                                        let l349 = *base.add(8).cast::<i64>();
                                                        let l350 = *base.add(16).cast::<i32>();
                                                        let l351 = *base.add(24).cast::<i64>();
                                                        EndRemoteWriteParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l349 as u64,
                                                                nanoseconds: l350 as u32,
                                                            },
                                                            begin_index: l351 as u64,
                                                        }
                                                    };
                                                    OplogEntry::EndRemoteWrite(e620)
                                                }
                                                15 => {
                                                    let e620 = {
                                                        let l352 = *base.add(8).cast::<i64>();
                                                        let l353 = *base.add(16).cast::<i32>();
                                                        let l354 = i32::from(*base.add(24).cast::<u8>());
                                                        let v414 = match l354 {
                                                            0 => {
                                                                let e414 = {
                                                                    let l355 = *base.add(32).cast::<*mut u8>();
                                                                    let l356 = *base.add(36).cast::<usize>();
                                                                    let len357 = l356;
                                                                    let bytes357 = _rt::Vec::from_raw_parts(
                                                                        l355.cast(),
                                                                        len357,
                                                                        len357,
                                                                    );
                                                                    let l358 = *base.add(40).cast::<*mut u8>();
                                                                    let l359 = *base.add(44).cast::<usize>();
                                                                    let len360 = l359;
                                                                    let bytes360 = _rt::Vec::from_raw_parts(
                                                                        l358.cast(),
                                                                        len360,
                                                                        len360,
                                                                    );
                                                                    let l361 = i32::from(*base.add(48).cast::<u8>());
                                                                    ExportedFunctionInvocationParameters {
                                                                        idempotency_key: _rt::string_lift(bytes357),
                                                                        function_name: _rt::string_lift(bytes360),
                                                                        input: match l361 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l362 = *base.add(52).cast::<*mut u8>();
                                                                                    let l363 = *base.add(56).cast::<usize>();
                                                                                    let base412 = l362;
                                                                                    let len412 = l363;
                                                                                    let mut result412 = _rt::Vec::with_capacity(len412);
                                                                                    for i in 0..len412 {
                                                                                        let base = base412.add(i * 8);
                                                                                        let e412 = {
                                                                                            let l364 = *base.add(0).cast::<*mut u8>();
                                                                                            let l365 = *base.add(4).cast::<usize>();
                                                                                            let base411 = l364;
                                                                                            let len411 = l365;
                                                                                            let mut result411 = _rt::Vec::with_capacity(len411);
                                                                                            for i in 0..len411 {
                                                                                                let base = base411.add(i * 24);
                                                                                                let e411 = {
                                                                                                    let l366 = i32::from(*base.add(0).cast::<u8>());
                                                                                                    use super::super::super::golem::rpc::types::WitNode as V410;
                                                                                                    let v410 = match l366 {
                                                                                                        0 => {
                                                                                                            let e410 = {
                                                                                                                let l367 = *base.add(8).cast::<*mut u8>();
                                                                                                                let l368 = *base.add(12).cast::<usize>();
                                                                                                                let len369 = l368;
                                                                                                                _rt::Vec::from_raw_parts(l367.cast(), len369, len369)
                                                                                                            };
                                                                                                            V410::RecordValue(e410)
                                                                                                        }
                                                                                                        1 => {
                                                                                                            let e410 = {
                                                                                                                let l370 = *base.add(8).cast::<i32>();
                                                                                                                let l371 = i32::from(*base.add(12).cast::<u8>());
                                                                                                                (
                                                                                                                    l370 as u32,
                                                                                                                    match l371 {
                                                                                                                        0 => None,
                                                                                                                        1 => {
                                                                                                                            let e = {
                                                                                                                                let l372 = *base.add(16).cast::<i32>();
                                                                                                                                l372
                                                                                                                            };
                                                                                                                            Some(e)
                                                                                                                        }
                                                                                                                        _ => _rt::invalid_enum_discriminant(),
                                                                                                                    },
                                                                                                                )
                                                                                                            };
                                                                                                            V410::VariantValue(e410)
                                                                                                        }
                                                                                                        2 => {
                                                                                                            let e410 = {
                                                                                                                let l373 = *base.add(8).cast::<i32>();
                                                                                                                l373 as u32
                                                                                                            };
                                                                                                            V410::EnumValue(e410)
                                                                                                        }
                                                                                                        3 => {
                                                                                                            let e410 = {
                                                                                                                let l374 = *base.add(8).cast::<*mut u8>();
                                                                                                                let l375 = *base.add(12).cast::<usize>();
                                                                                                                let base377 = l374;
                                                                                                                let len377 = l375;
                                                                                                                let mut result377 = _rt::Vec::with_capacity(len377);
                                                                                                                for i in 0..len377 {
                                                                                                                    let base = base377.add(i * 1);
                                                                                                                    let e377 = {
                                                                                                                        let l376 = i32::from(*base.add(0).cast::<u8>());
                                                                                                                        _rt::bool_lift(l376 as u8)
                                                                                                                    };
                                                                                                                    result377.push(e377);
                                                                                                                }
                                                                                                                _rt::cabi_dealloc(base377, len377 * 1, 1);
                                                                                                                result377
                                                                                                            };
                                                                                                            V410::FlagsValue(e410)
                                                                                                        }
                                                                                                        4 => {
                                                                                                            let e410 = {
                                                                                                                let l378 = *base.add(8).cast::<*mut u8>();
                                                                                                                let l379 = *base.add(12).cast::<usize>();
                                                                                                                let len380 = l379;
                                                                                                                _rt::Vec::from_raw_parts(l378.cast(), len380, len380)
                                                                                                            };
                                                                                                            V410::TupleValue(e410)
                                                                                                        }
                                                                                                        5 => {
                                                                                                            let e410 = {
                                                                                                                let l381 = *base.add(8).cast::<*mut u8>();
                                                                                                                let l382 = *base.add(12).cast::<usize>();
                                                                                                                let len383 = l382;
                                                                                                                _rt::Vec::from_raw_parts(l381.cast(), len383, len383)
                                                                                                            };
                                                                                                            V410::ListValue(e410)
                                                                                                        }
                                                                                                        6 => {
                                                                                                            let e410 = {
                                                                                                                let l384 = i32::from(*base.add(8).cast::<u8>());
                                                                                                                match l384 {
                                                                                                                    0 => None,
                                                                                                                    1 => {
                                                                                                                        let e = {
                                                                                                                            let l385 = *base.add(12).cast::<i32>();
                                                                                                                            l385
                                                                                                                        };
                                                                                                                        Some(e)
                                                                                                                    }
                                                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                                                }
                                                                                                            };
                                                                                                            V410::OptionValue(e410)
                                                                                                        }
                                                                                                        7 => {
                                                                                                            let e410 = {
                                                                                                                let l386 = i32::from(*base.add(8).cast::<u8>());
                                                                                                                match l386 {
                                                                                                                    0 => {
                                                                                                                        let e = {
                                                                                                                            let l387 = i32::from(*base.add(12).cast::<u8>());
                                                                                                                            match l387 {
                                                                                                                                0 => None,
                                                                                                                                1 => {
                                                                                                                                    let e = {
                                                                                                                                        let l388 = *base.add(16).cast::<i32>();
                                                                                                                                        l388
                                                                                                                                    };
                                                                                                                                    Some(e)
                                                                                                                                }
                                                                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                                                                            }
                                                                                                                        };
                                                                                                                        Ok(e)
                                                                                                                    }
                                                                                                                    1 => {
                                                                                                                        let e = {
                                                                                                                            let l389 = i32::from(*base.add(12).cast::<u8>());
                                                                                                                            match l389 {
                                                                                                                                0 => None,
                                                                                                                                1 => {
                                                                                                                                    let e = {
                                                                                                                                        let l390 = *base.add(16).cast::<i32>();
                                                                                                                                        l390
                                                                                                                                    };
                                                                                                                                    Some(e)
                                                                                                                                }
                                                                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                                                                            }
                                                                                                                        };
                                                                                                                        Err(e)
                                                                                                                    }
                                                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                                                }
                                                                                                            };
                                                                                                            V410::ResultValue(e410)
                                                                                                        }
                                                                                                        8 => {
                                                                                                            let e410 = {
                                                                                                                let l391 = i32::from(*base.add(8).cast::<u8>());
                                                                                                                l391 as u8
                                                                                                            };
                                                                                                            V410::PrimU8(e410)
                                                                                                        }
                                                                                                        9 => {
                                                                                                            let e410 = {
                                                                                                                let l392 = i32::from(*base.add(8).cast::<u16>());
                                                                                                                l392 as u16
                                                                                                            };
                                                                                                            V410::PrimU16(e410)
                                                                                                        }
                                                                                                        10 => {
                                                                                                            let e410 = {
                                                                                                                let l393 = *base.add(8).cast::<i32>();
                                                                                                                l393 as u32
                                                                                                            };
                                                                                                            V410::PrimU32(e410)
                                                                                                        }
                                                                                                        11 => {
                                                                                                            let e410 = {
                                                                                                                let l394 = *base.add(8).cast::<i64>();
                                                                                                                l394 as u64
                                                                                                            };
                                                                                                            V410::PrimU64(e410)
                                                                                                        }
                                                                                                        12 => {
                                                                                                            let e410 = {
                                                                                                                let l395 = i32::from(*base.add(8).cast::<i8>());
                                                                                                                l395 as i8
                                                                                                            };
                                                                                                            V410::PrimS8(e410)
                                                                                                        }
                                                                                                        13 => {
                                                                                                            let e410 = {
                                                                                                                let l396 = i32::from(*base.add(8).cast::<i16>());
                                                                                                                l396 as i16
                                                                                                            };
                                                                                                            V410::PrimS16(e410)
                                                                                                        }
                                                                                                        14 => {
                                                                                                            let e410 = {
                                                                                                                let l397 = *base.add(8).cast::<i32>();
                                                                                                                l397
                                                                                                            };
                                                                                                            V410::PrimS32(e410)
                                                                                                        }
                                                                                                        15 => {
                                                                                                            let e410 = {
                                                                                                                let l398 = *base.add(8).cast::<i64>();
                                                                                                                l398
                                                                                                            };
                                                                                                            V410::PrimS64(e410)
                                                                                                        }
                                                                                                        16 => {
                                                                                                            let e410 = {
                                                                                                                let l399 = *base.add(8).cast::<f32>();
                                                                                                                l399
                                                                                                            };
                                                                                                            V410::PrimFloat32(e410)
                                                                                                        }
                                                                                                        17 => {
                                                                                                            let e410 = {
                                                                                                                let l400 = *base.add(8).cast::<f64>();
                                                                                                                l400
                                                                                                            };
                                                                                                            V410::PrimFloat64(e410)
                                                                                                        }
                                                                                                        18 => {
                                                                                                            let e410 = {
                                                                                                                let l401 = *base.add(8).cast::<i32>();
                                                                                                                _rt::char_lift(l401 as u32)
                                                                                                            };
                                                                                                            V410::PrimChar(e410)
                                                                                                        }
                                                                                                        19 => {
                                                                                                            let e410 = {
                                                                                                                let l402 = i32::from(*base.add(8).cast::<u8>());
                                                                                                                _rt::bool_lift(l402 as u8)
                                                                                                            };
                                                                                                            V410::PrimBool(e410)
                                                                                                        }
                                                                                                        20 => {
                                                                                                            let e410 = {
                                                                                                                let l403 = *base.add(8).cast::<*mut u8>();
                                                                                                                let l404 = *base.add(12).cast::<usize>();
                                                                                                                let len405 = l404;
                                                                                                                let bytes405 = _rt::Vec::from_raw_parts(
                                                                                                                    l403.cast(),
                                                                                                                    len405,
                                                                                                                    len405,
                                                                                                                );
                                                                                                                _rt::string_lift(bytes405)
                                                                                                            };
                                                                                                            V410::PrimString(e410)
                                                                                                        }
                                                                                                        n => {
                                                                                                            debug_assert_eq!(n, 21, "invalid enum discriminant");
                                                                                                            let e410 = {
                                                                                                                let l406 = *base.add(8).cast::<*mut u8>();
                                                                                                                let l407 = *base.add(12).cast::<usize>();
                                                                                                                let len408 = l407;
                                                                                                                let bytes408 = _rt::Vec::from_raw_parts(
                                                                                                                    l406.cast(),
                                                                                                                    len408,
                                                                                                                    len408,
                                                                                                                );
                                                                                                                let l409 = *base.add(16).cast::<i64>();
                                                                                                                (
                                                                                                                    super::super::super::golem::rpc::types::Uri {
                                                                                                                        value: _rt::string_lift(bytes408),
                                                                                                                    },
                                                                                                                    l409 as u64,
                                                                                                                )
                                                                                                            };
                                                                                                            V410::Handle(e410)
                                                                                                        }
                                                                                                    };
                                                                                                    v410
                                                                                                };
                                                                                                result411.push(e411);
                                                                                            }
                                                                                            _rt::cabi_dealloc(base411, len411 * 24, 8);
                                                                                            super::super::super::golem::rpc::types::WitValue {
                                                                                                nodes: result411,
                                                                                            }
                                                                                        };
                                                                                        result412.push(e412);
                                                                                    }
                                                                                    _rt::cabi_dealloc(base412, len412 * 8, 4);
                                                                                    result412
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        },
                                                                    }
                                                                };
                                                                WorkerInvocation::ExportedFunction(e414)
                                                            }
                                                            n => {
                                                                debug_assert_eq!(n, 1, "invalid enum discriminant");
                                                                let e414 = {
                                                                    let l413 = *base.add(32).cast::<i64>();
                                                                    l413 as u64
                                                                };
                                                                WorkerInvocation::ManualUpdate(e414)
                                                            }
                                                        };
                                                        PendingWorkerInvocationParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l352 as u64,
                                                                nanoseconds: l353 as u32,
                                                            },
                                                            invocation: v414,
                                                        }
                                                    };
                                                    OplogEntry::PendingWorkerInvocation(e620)
                                                }
                                                16 => {
                                                    let e620 = {
                                                        let l415 = *base.add(8).cast::<i64>();
                                                        let l416 = *base.add(16).cast::<i32>();
                                                        let l417 = *base.add(24).cast::<i64>();
                                                        let l418 = i32::from(*base.add(32).cast::<u8>());
                                                        let v422 = match l418 {
                                                            0 => UpdateDescription::AutoUpdate,
                                                            n => {
                                                                debug_assert_eq!(n, 1, "invalid enum discriminant");
                                                                let e422 = {
                                                                    let l419 = *base.add(36).cast::<*mut u8>();
                                                                    let l420 = *base.add(40).cast::<usize>();
                                                                    let len421 = l420;
                                                                    _rt::Vec::from_raw_parts(l419.cast(), len421, len421)
                                                                };
                                                                UpdateDescription::SnapshotBased(e422)
                                                            }
                                                        };
                                                        PendingUpdateParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l415 as u64,
                                                                nanoseconds: l416 as u32,
                                                            },
                                                            target_version: l417 as u64,
                                                            update_description: v422,
                                                        }
                                                    };
                                                    OplogEntry::PendingUpdate(e620)
                                                }
                                                17 => {
                                                    let e620 = {
                                                        let l423 = *base.add(8).cast::<i64>();
                                                        let l424 = *base.add(16).cast::<i32>();
                                                        let l425 = *base.add(24).cast::<i64>();
                                                        let l426 = *base.add(32).cast::<i64>();
                                                        let l427 = *base.add(40).cast::<*mut u8>();
                                                        let l428 = *base.add(44).cast::<usize>();
                                                        let base446 = l427;
                                                        let len446 = l428;
                                                        let mut result446 = _rt::Vec::with_capacity(len446);
                                                        for i in 0..len446 {
                                                            let base = base446.add(i * 40);
                                                            let e446 = {
                                                                let l429 = *base.add(0).cast::<i64>();
                                                                let l430 = *base.add(8).cast::<i64>();
                                                                let l431 = *base.add(16).cast::<*mut u8>();
                                                                let l432 = *base.add(20).cast::<usize>();
                                                                let len433 = l432;
                                                                let bytes433 = _rt::Vec::from_raw_parts(
                                                                    l431.cast(),
                                                                    len433,
                                                                    len433,
                                                                );
                                                                let l434 = *base.add(24).cast::<*mut u8>();
                                                                let l435 = *base.add(28).cast::<usize>();
                                                                let len436 = l435;
                                                                let bytes436 = _rt::Vec::from_raw_parts(
                                                                    l434.cast(),
                                                                    len436,
                                                                    len436,
                                                                );
                                                                let l437 = *base.add(32).cast::<*mut u8>();
                                                                let l438 = *base.add(36).cast::<usize>();
                                                                let base445 = l437;
                                                                let len445 = l438;
                                                                let mut result445 = _rt::Vec::with_capacity(len445);
                                                                for i in 0..len445 {
                                                                    let base = base445.add(i * 16);
                                                                    let e445 = {
                                                                        let l439 = *base.add(0).cast::<*mut u8>();
                                                                        let l440 = *base.add(4).cast::<usize>();
                                                                        let len441 = l440;
                                                                        let bytes441 = _rt::Vec::from_raw_parts(
                                                                            l439.cast(),
                                                                            len441,
                                                                            len441,
                                                                        );
                                                                        let l442 = *base.add(8).cast::<*mut u8>();
                                                                        let l443 = *base.add(12).cast::<usize>();
                                                                        let len444 = l443;
                                                                        let bytes444 = _rt::Vec::from_raw_parts(
                                                                            l442.cast(),
                                                                            len444,
                                                                            len444,
                                                                        );
                                                                        (_rt::string_lift(bytes441), _rt::string_lift(bytes444))
                                                                    };
                                                                    result445.push(e445);
                                                                }
                                                                _rt::cabi_dealloc(base445, len445 * 16, 4);
                                                                PluginInstallationDescription {
                                                                    installation_id: super::super::super::golem::api::host::Uuid {
                                                                        high_bits: l429 as u64,
                                                                        low_bits: l430 as u64,
                                                                    },
                                                                    name: _rt::string_lift(bytes433),
                                                                    version: _rt::string_lift(bytes436),
                                                                    parameters: result445,
                                                                }
                                                            };
                                                            result446.push(e446);
                                                        }
                                                        _rt::cabi_dealloc(base446, len446 * 40, 8);
                                                        SuccessfulUpdateParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l423 as u64,
                                                                nanoseconds: l424 as u32,
                                                            },
                                                            target_version: l425 as u64,
                                                            new_component_size: l426 as u64,
                                                            new_active_plugins: result446,
                                                        }
                                                    };
                                                    OplogEntry::SuccessfulUpdate(e620)
                                                }
                                                18 => {
                                                    let e620 = {
                                                        let l447 = *base.add(8).cast::<i64>();
                                                        let l448 = *base.add(16).cast::<i32>();
                                                        let l449 = *base.add(24).cast::<i64>();
                                                        let l450 = i32::from(*base.add(32).cast::<u8>());
                                                        FailedUpdateParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l447 as u64,
                                                                nanoseconds: l448 as u32,
                                                            },
                                                            target_version: l449 as u64,
                                                            details: match l450 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l451 = *base.add(36).cast::<*mut u8>();
                                                                        let l452 = *base.add(40).cast::<usize>();
                                                                        let len453 = l452;
                                                                        let bytes453 = _rt::Vec::from_raw_parts(
                                                                            l451.cast(),
                                                                            len453,
                                                                            len453,
                                                                        );
                                                                        _rt::string_lift(bytes453)
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                        }
                                                    };
                                                    OplogEntry::FailedUpdate(e620)
                                                }
                                                19 => {
                                                    let e620 = {
                                                        let l454 = *base.add(8).cast::<i64>();
                                                        let l455 = *base.add(16).cast::<i32>();
                                                        let l456 = *base.add(24).cast::<i64>();
                                                        GrowMemoryParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l454 as u64,
                                                                nanoseconds: l455 as u32,
                                                            },
                                                            delta: l456 as u64,
                                                        }
                                                    };
                                                    OplogEntry::GrowMemory(e620)
                                                }
                                                20 => {
                                                    let e620 = {
                                                        let l457 = *base.add(8).cast::<i64>();
                                                        let l458 = *base.add(16).cast::<i32>();
                                                        let l459 = *base.add(24).cast::<i64>();
                                                        CreateResourceParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l457 as u64,
                                                                nanoseconds: l458 as u32,
                                                            },
                                                            resource_id: l459 as u64,
                                                        }
                                                    };
                                                    OplogEntry::CreateResource(e620)
                                                }
                                                21 => {
                                                    let e620 = {
                                                        let l460 = *base.add(8).cast::<i64>();
                                                        let l461 = *base.add(16).cast::<i32>();
                                                        let l462 = *base.add(24).cast::<i64>();
                                                        DropResourceParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l460 as u64,
                                                                nanoseconds: l461 as u32,
                                                            },
                                                            resource_id: l462 as u64,
                                                        }
                                                    };
                                                    OplogEntry::DropResource(e620)
                                                }
                                                22 => {
                                                    let e620 = {
                                                        let l463 = *base.add(8).cast::<i64>();
                                                        let l464 = *base.add(16).cast::<i32>();
                                                        let l465 = *base.add(24).cast::<i64>();
                                                        let l466 = *base.add(32).cast::<*mut u8>();
                                                        let l467 = *base.add(36).cast::<usize>();
                                                        let len468 = l467;
                                                        let bytes468 = _rt::Vec::from_raw_parts(
                                                            l466.cast(),
                                                            len468,
                                                            len468,
                                                        );
                                                        let l469 = *base.add(40).cast::<*mut u8>();
                                                        let l470 = *base.add(44).cast::<usize>();
                                                        let base519 = l469;
                                                        let len519 = l470;
                                                        let mut result519 = _rt::Vec::with_capacity(len519);
                                                        for i in 0..len519 {
                                                            let base = base519.add(i * 8);
                                                            let e519 = {
                                                                let l471 = *base.add(0).cast::<*mut u8>();
                                                                let l472 = *base.add(4).cast::<usize>();
                                                                let base518 = l471;
                                                                let len518 = l472;
                                                                let mut result518 = _rt::Vec::with_capacity(len518);
                                                                for i in 0..len518 {
                                                                    let base = base518.add(i * 24);
                                                                    let e518 = {
                                                                        let l473 = i32::from(*base.add(0).cast::<u8>());
                                                                        use super::super::super::golem::rpc::types::WitNode as V517;
                                                                        let v517 = match l473 {
                                                                            0 => {
                                                                                let e517 = {
                                                                                    let l474 = *base.add(8).cast::<*mut u8>();
                                                                                    let l475 = *base.add(12).cast::<usize>();
                                                                                    let len476 = l475;
                                                                                    _rt::Vec::from_raw_parts(l474.cast(), len476, len476)
                                                                                };
                                                                                V517::RecordValue(e517)
                                                                            }
                                                                            1 => {
                                                                                let e517 = {
                                                                                    let l477 = *base.add(8).cast::<i32>();
                                                                                    let l478 = i32::from(*base.add(12).cast::<u8>());
                                                                                    (
                                                                                        l477 as u32,
                                                                                        match l478 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l479 = *base.add(16).cast::<i32>();
                                                                                                    l479
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        },
                                                                                    )
                                                                                };
                                                                                V517::VariantValue(e517)
                                                                            }
                                                                            2 => {
                                                                                let e517 = {
                                                                                    let l480 = *base.add(8).cast::<i32>();
                                                                                    l480 as u32
                                                                                };
                                                                                V517::EnumValue(e517)
                                                                            }
                                                                            3 => {
                                                                                let e517 = {
                                                                                    let l481 = *base.add(8).cast::<*mut u8>();
                                                                                    let l482 = *base.add(12).cast::<usize>();
                                                                                    let base484 = l481;
                                                                                    let len484 = l482;
                                                                                    let mut result484 = _rt::Vec::with_capacity(len484);
                                                                                    for i in 0..len484 {
                                                                                        let base = base484.add(i * 1);
                                                                                        let e484 = {
                                                                                            let l483 = i32::from(*base.add(0).cast::<u8>());
                                                                                            _rt::bool_lift(l483 as u8)
                                                                                        };
                                                                                        result484.push(e484);
                                                                                    }
                                                                                    _rt::cabi_dealloc(base484, len484 * 1, 1);
                                                                                    result484
                                                                                };
                                                                                V517::FlagsValue(e517)
                                                                            }
                                                                            4 => {
                                                                                let e517 = {
                                                                                    let l485 = *base.add(8).cast::<*mut u8>();
                                                                                    let l486 = *base.add(12).cast::<usize>();
                                                                                    let len487 = l486;
                                                                                    _rt::Vec::from_raw_parts(l485.cast(), len487, len487)
                                                                                };
                                                                                V517::TupleValue(e517)
                                                                            }
                                                                            5 => {
                                                                                let e517 = {
                                                                                    let l488 = *base.add(8).cast::<*mut u8>();
                                                                                    let l489 = *base.add(12).cast::<usize>();
                                                                                    let len490 = l489;
                                                                                    _rt::Vec::from_raw_parts(l488.cast(), len490, len490)
                                                                                };
                                                                                V517::ListValue(e517)
                                                                            }
                                                                            6 => {
                                                                                let e517 = {
                                                                                    let l491 = i32::from(*base.add(8).cast::<u8>());
                                                                                    match l491 {
                                                                                        0 => None,
                                                                                        1 => {
                                                                                            let e = {
                                                                                                let l492 = *base.add(12).cast::<i32>();
                                                                                                l492
                                                                                            };
                                                                                            Some(e)
                                                                                        }
                                                                                        _ => _rt::invalid_enum_discriminant(),
                                                                                    }
                                                                                };
                                                                                V517::OptionValue(e517)
                                                                            }
                                                                            7 => {
                                                                                let e517 = {
                                                                                    let l493 = i32::from(*base.add(8).cast::<u8>());
                                                                                    match l493 {
                                                                                        0 => {
                                                                                            let e = {
                                                                                                let l494 = i32::from(*base.add(12).cast::<u8>());
                                                                                                match l494 {
                                                                                                    0 => None,
                                                                                                    1 => {
                                                                                                        let e = {
                                                                                                            let l495 = *base.add(16).cast::<i32>();
                                                                                                            l495
                                                                                                        };
                                                                                                        Some(e)
                                                                                                    }
                                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                                }
                                                                                            };
                                                                                            Ok(e)
                                                                                        }
                                                                                        1 => {
                                                                                            let e = {
                                                                                                let l496 = i32::from(*base.add(12).cast::<u8>());
                                                                                                match l496 {
                                                                                                    0 => None,
                                                                                                    1 => {
                                                                                                        let e = {
                                                                                                            let l497 = *base.add(16).cast::<i32>();
                                                                                                            l497
                                                                                                        };
                                                                                                        Some(e)
                                                                                                    }
                                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                                }
                                                                                            };
                                                                                            Err(e)
                                                                                        }
                                                                                        _ => _rt::invalid_enum_discriminant(),
                                                                                    }
                                                                                };
                                                                                V517::ResultValue(e517)
                                                                            }
                                                                            8 => {
                                                                                let e517 = {
                                                                                    let l498 = i32::from(*base.add(8).cast::<u8>());
                                                                                    l498 as u8
                                                                                };
                                                                                V517::PrimU8(e517)
                                                                            }
                                                                            9 => {
                                                                                let e517 = {
                                                                                    let l499 = i32::from(*base.add(8).cast::<u16>());
                                                                                    l499 as u16
                                                                                };
                                                                                V517::PrimU16(e517)
                                                                            }
                                                                            10 => {
                                                                                let e517 = {
                                                                                    let l500 = *base.add(8).cast::<i32>();
                                                                                    l500 as u32
                                                                                };
                                                                                V517::PrimU32(e517)
                                                                            }
                                                                            11 => {
                                                                                let e517 = {
                                                                                    let l501 = *base.add(8).cast::<i64>();
                                                                                    l501 as u64
                                                                                };
                                                                                V517::PrimU64(e517)
                                                                            }
                                                                            12 => {
                                                                                let e517 = {
                                                                                    let l502 = i32::from(*base.add(8).cast::<i8>());
                                                                                    l502 as i8
                                                                                };
                                                                                V517::PrimS8(e517)
                                                                            }
                                                                            13 => {
                                                                                let e517 = {
                                                                                    let l503 = i32::from(*base.add(8).cast::<i16>());
                                                                                    l503 as i16
                                                                                };
                                                                                V517::PrimS16(e517)
                                                                            }
                                                                            14 => {
                                                                                let e517 = {
                                                                                    let l504 = *base.add(8).cast::<i32>();
                                                                                    l504
                                                                                };
                                                                                V517::PrimS32(e517)
                                                                            }
                                                                            15 => {
                                                                                let e517 = {
                                                                                    let l505 = *base.add(8).cast::<i64>();
                                                                                    l505
                                                                                };
                                                                                V517::PrimS64(e517)
                                                                            }
                                                                            16 => {
                                                                                let e517 = {
                                                                                    let l506 = *base.add(8).cast::<f32>();
                                                                                    l506
                                                                                };
                                                                                V517::PrimFloat32(e517)
                                                                            }
                                                                            17 => {
                                                                                let e517 = {
                                                                                    let l507 = *base.add(8).cast::<f64>();
                                                                                    l507
                                                                                };
                                                                                V517::PrimFloat64(e517)
                                                                            }
                                                                            18 => {
                                                                                let e517 = {
                                                                                    let l508 = *base.add(8).cast::<i32>();
                                                                                    _rt::char_lift(l508 as u32)
                                                                                };
                                                                                V517::PrimChar(e517)
                                                                            }
                                                                            19 => {
                                                                                let e517 = {
                                                                                    let l509 = i32::from(*base.add(8).cast::<u8>());
                                                                                    _rt::bool_lift(l509 as u8)
                                                                                };
                                                                                V517::PrimBool(e517)
                                                                            }
                                                                            20 => {
                                                                                let e517 = {
                                                                                    let l510 = *base.add(8).cast::<*mut u8>();
                                                                                    let l511 = *base.add(12).cast::<usize>();
                                                                                    let len512 = l511;
                                                                                    let bytes512 = _rt::Vec::from_raw_parts(
                                                                                        l510.cast(),
                                                                                        len512,
                                                                                        len512,
                                                                                    );
                                                                                    _rt::string_lift(bytes512)
                                                                                };
                                                                                V517::PrimString(e517)
                                                                            }
                                                                            n => {
                                                                                debug_assert_eq!(n, 21, "invalid enum discriminant");
                                                                                let e517 = {
                                                                                    let l513 = *base.add(8).cast::<*mut u8>();
                                                                                    let l514 = *base.add(12).cast::<usize>();
                                                                                    let len515 = l514;
                                                                                    let bytes515 = _rt::Vec::from_raw_parts(
                                                                                        l513.cast(),
                                                                                        len515,
                                                                                        len515,
                                                                                    );
                                                                                    let l516 = *base.add(16).cast::<i64>();
                                                                                    (
                                                                                        super::super::super::golem::rpc::types::Uri {
                                                                                            value: _rt::string_lift(bytes515),
                                                                                        },
                                                                                        l516 as u64,
                                                                                    )
                                                                                };
                                                                                V517::Handle(e517)
                                                                            }
                                                                        };
                                                                        v517
                                                                    };
                                                                    result518.push(e518);
                                                                }
                                                                _rt::cabi_dealloc(base518, len518 * 24, 8);
                                                                super::super::super::golem::rpc::types::WitValue {
                                                                    nodes: result518,
                                                                }
                                                            };
                                                            result519.push(e519);
                                                        }
                                                        _rt::cabi_dealloc(base519, len519 * 8, 4);
                                                        DescribeResourceParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l463 as u64,
                                                                nanoseconds: l464 as u32,
                                                            },
                                                            resource_id: l465 as u64,
                                                            resource_name: _rt::string_lift(bytes468),
                                                            resource_params: result519,
                                                        }
                                                    };
                                                    OplogEntry::DescribeResource(e620)
                                                }
                                                23 => {
                                                    let e620 = {
                                                        let l520 = *base.add(8).cast::<i64>();
                                                        let l521 = *base.add(16).cast::<i32>();
                                                        let l522 = i32::from(*base.add(24).cast::<u8>());
                                                        let l523 = *base.add(28).cast::<*mut u8>();
                                                        let l524 = *base.add(32).cast::<usize>();
                                                        let len525 = l524;
                                                        let bytes525 = _rt::Vec::from_raw_parts(
                                                            l523.cast(),
                                                            len525,
                                                            len525,
                                                        );
                                                        let l526 = *base.add(36).cast::<*mut u8>();
                                                        let l527 = *base.add(40).cast::<usize>();
                                                        let len528 = l527;
                                                        let bytes528 = _rt::Vec::from_raw_parts(
                                                            l526.cast(),
                                                            len528,
                                                            len528,
                                                        );
                                                        LogParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l520 as u64,
                                                                nanoseconds: l521 as u32,
                                                            },
                                                            level: LogLevel::_lift(l522 as u8),
                                                            context: _rt::string_lift(bytes525),
                                                            message: _rt::string_lift(bytes528),
                                                        }
                                                    };
                                                    OplogEntry::Log(e620)
                                                }
                                                24 => {
                                                    let e620 = {
                                                        let l529 = *base.add(8).cast::<i64>();
                                                        let l530 = *base.add(16).cast::<i32>();
                                                        super::super::super::wasi::clocks::wall_clock::Datetime {
                                                            seconds: l529 as u64,
                                                            nanoseconds: l530 as u32,
                                                        }
                                                    };
                                                    OplogEntry::Restart(e620)
                                                }
                                                25 => {
                                                    let e620 = {
                                                        let l531 = *base.add(8).cast::<i64>();
                                                        let l532 = *base.add(16).cast::<i32>();
                                                        let l533 = *base.add(24).cast::<i64>();
                                                        let l534 = *base.add(32).cast::<i64>();
                                                        let l535 = *base.add(40).cast::<*mut u8>();
                                                        let l536 = *base.add(44).cast::<usize>();
                                                        let len537 = l536;
                                                        let bytes537 = _rt::Vec::from_raw_parts(
                                                            l535.cast(),
                                                            len537,
                                                            len537,
                                                        );
                                                        let l538 = *base.add(48).cast::<*mut u8>();
                                                        let l539 = *base.add(52).cast::<usize>();
                                                        let len540 = l539;
                                                        let bytes540 = _rt::Vec::from_raw_parts(
                                                            l538.cast(),
                                                            len540,
                                                            len540,
                                                        );
                                                        let l541 = *base.add(56).cast::<*mut u8>();
                                                        let l542 = *base.add(60).cast::<usize>();
                                                        let base549 = l541;
                                                        let len549 = l542;
                                                        let mut result549 = _rt::Vec::with_capacity(len549);
                                                        for i in 0..len549 {
                                                            let base = base549.add(i * 16);
                                                            let e549 = {
                                                                let l543 = *base.add(0).cast::<*mut u8>();
                                                                let l544 = *base.add(4).cast::<usize>();
                                                                let len545 = l544;
                                                                let bytes545 = _rt::Vec::from_raw_parts(
                                                                    l543.cast(),
                                                                    len545,
                                                                    len545,
                                                                );
                                                                let l546 = *base.add(8).cast::<*mut u8>();
                                                                let l547 = *base.add(12).cast::<usize>();
                                                                let len548 = l547;
                                                                let bytes548 = _rt::Vec::from_raw_parts(
                                                                    l546.cast(),
                                                                    len548,
                                                                    len548,
                                                                );
                                                                (_rt::string_lift(bytes545), _rt::string_lift(bytes548))
                                                            };
                                                            result549.push(e549);
                                                        }
                                                        _rt::cabi_dealloc(base549, len549 * 16, 4);
                                                        ActivatePluginParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l531 as u64,
                                                                nanoseconds: l532 as u32,
                                                            },
                                                            plugin: PluginInstallationDescription {
                                                                installation_id: super::super::super::golem::api::host::Uuid {
                                                                    high_bits: l533 as u64,
                                                                    low_bits: l534 as u64,
                                                                },
                                                                name: _rt::string_lift(bytes537),
                                                                version: _rt::string_lift(bytes540),
                                                                parameters: result549,
                                                            },
                                                        }
                                                    };
                                                    OplogEntry::ActivatePlugin(e620)
                                                }
                                                26 => {
                                                    let e620 = {
                                                        let l550 = *base.add(8).cast::<i64>();
                                                        let l551 = *base.add(16).cast::<i32>();
                                                        let l552 = *base.add(24).cast::<i64>();
                                                        let l553 = *base.add(32).cast::<i64>();
                                                        let l554 = *base.add(40).cast::<*mut u8>();
                                                        let l555 = *base.add(44).cast::<usize>();
                                                        let len556 = l555;
                                                        let bytes556 = _rt::Vec::from_raw_parts(
                                                            l554.cast(),
                                                            len556,
                                                            len556,
                                                        );
                                                        let l557 = *base.add(48).cast::<*mut u8>();
                                                        let l558 = *base.add(52).cast::<usize>();
                                                        let len559 = l558;
                                                        let bytes559 = _rt::Vec::from_raw_parts(
                                                            l557.cast(),
                                                            len559,
                                                            len559,
                                                        );
                                                        let l560 = *base.add(56).cast::<*mut u8>();
                                                        let l561 = *base.add(60).cast::<usize>();
                                                        let base568 = l560;
                                                        let len568 = l561;
                                                        let mut result568 = _rt::Vec::with_capacity(len568);
                                                        for i in 0..len568 {
                                                            let base = base568.add(i * 16);
                                                            let e568 = {
                                                                let l562 = *base.add(0).cast::<*mut u8>();
                                                                let l563 = *base.add(4).cast::<usize>();
                                                                let len564 = l563;
                                                                let bytes564 = _rt::Vec::from_raw_parts(
                                                                    l562.cast(),
                                                                    len564,
                                                                    len564,
                                                                );
                                                                let l565 = *base.add(8).cast::<*mut u8>();
                                                                let l566 = *base.add(12).cast::<usize>();
                                                                let len567 = l566;
                                                                let bytes567 = _rt::Vec::from_raw_parts(
                                                                    l565.cast(),
                                                                    len567,
                                                                    len567,
                                                                );
                                                                (_rt::string_lift(bytes564), _rt::string_lift(bytes567))
                                                            };
                                                            result568.push(e568);
                                                        }
                                                        _rt::cabi_dealloc(base568, len568 * 16, 4);
                                                        DeactivatePluginParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l550 as u64,
                                                                nanoseconds: l551 as u32,
                                                            },
                                                            plugin: PluginInstallationDescription {
                                                                installation_id: super::super::super::golem::api::host::Uuid {
                                                                    high_bits: l552 as u64,
                                                                    low_bits: l553 as u64,
                                                                },
                                                                name: _rt::string_lift(bytes556),
                                                                version: _rt::string_lift(bytes559),
                                                                parameters: result568,
                                                            },
                                                        }
                                                    };
                                                    OplogEntry::DeactivatePlugin(e620)
                                                }
                                                27 => {
                                                    let e620 = {
                                                        let l569 = *base.add(8).cast::<i64>();
                                                        let l570 = *base.add(16).cast::<i32>();
                                                        let l571 = *base.add(24).cast::<i64>();
                                                        let l572 = *base.add(32).cast::<i64>();
                                                        RevertParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l569 as u64,
                                                                nanoseconds: l570 as u32,
                                                            },
                                                            start: l571 as u64,
                                                            end: l572 as u64,
                                                        }
                                                    };
                                                    OplogEntry::Revert(e620)
                                                }
                                                28 => {
                                                    let e620 = {
                                                        let l573 = *base.add(8).cast::<i64>();
                                                        let l574 = *base.add(16).cast::<i32>();
                                                        let l575 = *base.add(24).cast::<*mut u8>();
                                                        let l576 = *base.add(28).cast::<usize>();
                                                        let len577 = l576;
                                                        let bytes577 = _rt::Vec::from_raw_parts(
                                                            l575.cast(),
                                                            len577,
                                                            len577,
                                                        );
                                                        CancelInvocationParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l573 as u64,
                                                                nanoseconds: l574 as u32,
                                                            },
                                                            idempotency_key: _rt::string_lift(bytes577),
                                                        }
                                                    };
                                                    OplogEntry::CancelInvocation(e620)
                                                }
                                                29 => {
                                                    let e620 = {
                                                        let l578 = *base.add(8).cast::<i64>();
                                                        let l579 = *base.add(16).cast::<i32>();
                                                        let l580 = *base.add(24).cast::<*mut u8>();
                                                        let l581 = *base.add(28).cast::<usize>();
                                                        let len582 = l581;
                                                        let bytes582 = _rt::Vec::from_raw_parts(
                                                            l580.cast(),
                                                            len582,
                                                            len582,
                                                        );
                                                        let l583 = i32::from(*base.add(32).cast::<u8>());
                                                        let l587 = i32::from(*base.add(44).cast::<u8>());
                                                        let l591 = *base.add(56).cast::<*mut u8>();
                                                        let l592 = *base.add(60).cast::<usize>();
                                                        let base601 = l591;
                                                        let len601 = l592;
                                                        let mut result601 = _rt::Vec::with_capacity(len601);
                                                        for i in 0..len601 {
                                                            let base = base601.add(i * 20);
                                                            let e601 = {
                                                                let l593 = *base.add(0).cast::<*mut u8>();
                                                                let l594 = *base.add(4).cast::<usize>();
                                                                let len595 = l594;
                                                                let bytes595 = _rt::Vec::from_raw_parts(
                                                                    l593.cast(),
                                                                    len595,
                                                                    len595,
                                                                );
                                                                let l596 = i32::from(*base.add(8).cast::<u8>());
                                                                use super::super::super::golem::api::context::AttributeValue as V600;
                                                                let v600 = match l596 {
                                                                    n => {
                                                                        debug_assert_eq!(n, 0, "invalid enum discriminant");
                                                                        let e600 = {
                                                                            let l597 = *base.add(12).cast::<*mut u8>();
                                                                            let l598 = *base.add(16).cast::<usize>();
                                                                            let len599 = l598;
                                                                            let bytes599 = _rt::Vec::from_raw_parts(
                                                                                l597.cast(),
                                                                                len599,
                                                                                len599,
                                                                            );
                                                                            _rt::string_lift(bytes599)
                                                                        };
                                                                        V600::String(e600)
                                                                    }
                                                                };
                                                                super::super::super::golem::api::context::Attribute {
                                                                    key: _rt::string_lift(bytes595),
                                                                    value: v600,
                                                                }
                                                            };
                                                            result601.push(e601);
                                                        }
                                                        _rt::cabi_dealloc(base601, len601 * 20, 4);
                                                        StartSpanParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l578 as u64,
                                                                nanoseconds: l579 as u32,
                                                            },
                                                            span_id: _rt::string_lift(bytes582),
                                                            parent: match l583 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l584 = *base.add(36).cast::<*mut u8>();
                                                                        let l585 = *base.add(40).cast::<usize>();
                                                                        let len586 = l585;
                                                                        let bytes586 = _rt::Vec::from_raw_parts(
                                                                            l584.cast(),
                                                                            len586,
                                                                            len586,
                                                                        );
                                                                        _rt::string_lift(bytes586)
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                            linked_context: match l587 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l588 = *base.add(48).cast::<*mut u8>();
                                                                        let l589 = *base.add(52).cast::<usize>();
                                                                        let len590 = l589;
                                                                        let bytes590 = _rt::Vec::from_raw_parts(
                                                                            l588.cast(),
                                                                            len590,
                                                                            len590,
                                                                        );
                                                                        _rt::string_lift(bytes590)
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                            attributes: result601,
                                                        }
                                                    };
                                                    OplogEntry::StartSpan(e620)
                                                }
                                                30 => {
                                                    let e620 = {
                                                        let l602 = *base.add(8).cast::<i64>();
                                                        let l603 = *base.add(16).cast::<i32>();
                                                        let l604 = *base.add(24).cast::<*mut u8>();
                                                        let l605 = *base.add(28).cast::<usize>();
                                                        let len606 = l605;
                                                        let bytes606 = _rt::Vec::from_raw_parts(
                                                            l604.cast(),
                                                            len606,
                                                            len606,
                                                        );
                                                        FinishSpanParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l602 as u64,
                                                                nanoseconds: l603 as u32,
                                                            },
                                                            span_id: _rt::string_lift(bytes606),
                                                        }
                                                    };
                                                    OplogEntry::FinishSpan(e620)
                                                }
                                                n => {
                                                    debug_assert_eq!(n, 31, "invalid enum discriminant");
                                                    let e620 = {
                                                        let l607 = *base.add(8).cast::<i64>();
                                                        let l608 = *base.add(16).cast::<i32>();
                                                        let l609 = *base.add(24).cast::<*mut u8>();
                                                        let l610 = *base.add(28).cast::<usize>();
                                                        let len611 = l610;
                                                        let bytes611 = _rt::Vec::from_raw_parts(
                                                            l609.cast(),
                                                            len611,
                                                            len611,
                                                        );
                                                        let l612 = *base.add(32).cast::<*mut u8>();
                                                        let l613 = *base.add(36).cast::<usize>();
                                                        let len614 = l613;
                                                        let bytes614 = _rt::Vec::from_raw_parts(
                                                            l612.cast(),
                                                            len614,
                                                            len614,
                                                        );
                                                        let l615 = i32::from(*base.add(40).cast::<u8>());
                                                        use super::super::super::golem::api::context::AttributeValue as V619;
                                                        let v619 = match l615 {
                                                            n => {
                                                                debug_assert_eq!(n, 0, "invalid enum discriminant");
                                                                let e619 = {
                                                                    let l616 = *base.add(44).cast::<*mut u8>();
                                                                    let l617 = *base.add(48).cast::<usize>();
                                                                    let len618 = l617;
                                                                    let bytes618 = _rt::Vec::from_raw_parts(
                                                                        l616.cast(),
                                                                        len618,
                                                                        len618,
                                                                    );
                                                                    _rt::string_lift(bytes618)
                                                                };
                                                                V619::String(e619)
                                                            }
                                                        };
                                                        SetSpanAttributeParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l607 as u64,
                                                                nanoseconds: l608 as u32,
                                                            },
                                                            span_id: _rt::string_lift(bytes611),
                                                            key: _rt::string_lift(bytes614),
                                                            value: v619,
                                                        }
                                                    };
                                                    OplogEntry::SetSpanAttribute(e620)
                                                }
                                            };
                                            v620
                                        };
                                        result621.push(e621);
                                    }
                                    _rt::cabi_dealloc(base621, len621 * 136, 8);
                                    result621
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl SearchOplog {
                #[allow(unused_unsafe, clippy::all)]
                pub fn new(worker_id: &WorkerId, text: &str) -> Self {
                    unsafe {
                        let super::super::super::golem::api::host::WorkerId {
                            component_id: component_id0,
                            worker_name: worker_name0,
                        } = worker_id;
                        let super::super::super::golem::api::host::ComponentId {
                            uuid: uuid1,
                        } = component_id0;
                        let super::super::super::golem::api::host::Uuid {
                            high_bits: high_bits2,
                            low_bits: low_bits2,
                        } = uuid1;
                        let vec3 = worker_name0;
                        let ptr3 = vec3.as_ptr().cast::<u8>();
                        let len3 = vec3.len();
                        let vec4 = text;
                        let ptr4 = vec4.as_ptr().cast::<u8>();
                        let len4 = vec4.len();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:api/oplog@1.1.5")]
                        extern "C" {
                            #[link_name = "[constructor]search-oplog"]
                            fn wit_import(
                                _: i64,
                                _: i64,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                            ) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i64,
                            _: i64,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                        ) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import(
                            _rt::as_i64(high_bits2),
                            _rt::as_i64(low_bits2),
                            ptr3.cast_mut(),
                            len3,
                            ptr4.cast_mut(),
                            len4,
                        );
                        SearchOplog::from_handle(ret as u32)
                    }
                }
            }
            impl SearchOplog {
                #[allow(unused_unsafe, clippy::all)]
                pub fn get_next(&self) -> Option<_rt::Vec<(OplogIndex, OplogEntry)>> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:api/oplog@1.1.5")]
                        extern "C" {
                            #[link_name = "[method]search-oplog.get-next"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<*mut u8>();
                                    let l3 = *ptr0.add(8).cast::<usize>();
                                    let base622 = l2;
                                    let len622 = l3;
                                    let mut result622 = _rt::Vec::with_capacity(len622);
                                    for i in 0..len622 {
                                        let base = base622.add(i * 144);
                                        let e622 = {
                                            let l4 = *base.add(0).cast::<i64>();
                                            let l5 = i32::from(*base.add(8).cast::<u8>());
                                            let v621 = match l5 {
                                                0 => {
                                                    let e621 = {
                                                        let l6 = *base.add(16).cast::<i64>();
                                                        let l7 = *base.add(24).cast::<i32>();
                                                        let l8 = *base.add(32).cast::<i64>();
                                                        let l9 = *base.add(40).cast::<i64>();
                                                        let l10 = *base.add(48).cast::<*mut u8>();
                                                        let l11 = *base.add(52).cast::<usize>();
                                                        let len12 = l11;
                                                        let bytes12 = _rt::Vec::from_raw_parts(
                                                            l10.cast(),
                                                            len12,
                                                            len12,
                                                        );
                                                        let l13 = *base.add(56).cast::<i64>();
                                                        let l14 = *base.add(64).cast::<*mut u8>();
                                                        let l15 = *base.add(68).cast::<usize>();
                                                        let base19 = l14;
                                                        let len19 = l15;
                                                        let mut result19 = _rt::Vec::with_capacity(len19);
                                                        for i in 0..len19 {
                                                            let base = base19.add(i * 8);
                                                            let e19 = {
                                                                let l16 = *base.add(0).cast::<*mut u8>();
                                                                let l17 = *base.add(4).cast::<usize>();
                                                                let len18 = l17;
                                                                let bytes18 = _rt::Vec::from_raw_parts(
                                                                    l16.cast(),
                                                                    len18,
                                                                    len18,
                                                                );
                                                                _rt::string_lift(bytes18)
                                                            };
                                                            result19.push(e19);
                                                        }
                                                        _rt::cabi_dealloc(base19, len19 * 8, 4);
                                                        let l20 = *base.add(72).cast::<*mut u8>();
                                                        let l21 = *base.add(76).cast::<usize>();
                                                        let base28 = l20;
                                                        let len28 = l21;
                                                        let mut result28 = _rt::Vec::with_capacity(len28);
                                                        for i in 0..len28 {
                                                            let base = base28.add(i * 16);
                                                            let e28 = {
                                                                let l22 = *base.add(0).cast::<*mut u8>();
                                                                let l23 = *base.add(4).cast::<usize>();
                                                                let len24 = l23;
                                                                let bytes24 = _rt::Vec::from_raw_parts(
                                                                    l22.cast(),
                                                                    len24,
                                                                    len24,
                                                                );
                                                                let l25 = *base.add(8).cast::<*mut u8>();
                                                                let l26 = *base.add(12).cast::<usize>();
                                                                let len27 = l26;
                                                                let bytes27 = _rt::Vec::from_raw_parts(
                                                                    l25.cast(),
                                                                    len27,
                                                                    len27,
                                                                );
                                                                (_rt::string_lift(bytes24), _rt::string_lift(bytes27))
                                                            };
                                                            result28.push(e28);
                                                        }
                                                        _rt::cabi_dealloc(base28, len28 * 16, 4);
                                                        let l29 = *base.add(80).cast::<*mut u8>();
                                                        let l30 = *base.add(84).cast::<usize>();
                                                        let len31 = l30;
                                                        let bytes31 = _rt::Vec::from_raw_parts(
                                                            l29.cast(),
                                                            len31,
                                                            len31,
                                                        );
                                                        let l32 = i32::from(*base.add(88).cast::<u8>());
                                                        let l38 = *base.add(120).cast::<i64>();
                                                        let l39 = *base.add(128).cast::<i64>();
                                                        let l40 = *base.add(136).cast::<*mut u8>();
                                                        let l41 = *base.add(140).cast::<usize>();
                                                        let base59 = l40;
                                                        let len59 = l41;
                                                        let mut result59 = _rt::Vec::with_capacity(len59);
                                                        for i in 0..len59 {
                                                            let base = base59.add(i * 40);
                                                            let e59 = {
                                                                let l42 = *base.add(0).cast::<i64>();
                                                                let l43 = *base.add(8).cast::<i64>();
                                                                let l44 = *base.add(16).cast::<*mut u8>();
                                                                let l45 = *base.add(20).cast::<usize>();
                                                                let len46 = l45;
                                                                let bytes46 = _rt::Vec::from_raw_parts(
                                                                    l44.cast(),
                                                                    len46,
                                                                    len46,
                                                                );
                                                                let l47 = *base.add(24).cast::<*mut u8>();
                                                                let l48 = *base.add(28).cast::<usize>();
                                                                let len49 = l48;
                                                                let bytes49 = _rt::Vec::from_raw_parts(
                                                                    l47.cast(),
                                                                    len49,
                                                                    len49,
                                                                );
                                                                let l50 = *base.add(32).cast::<*mut u8>();
                                                                let l51 = *base.add(36).cast::<usize>();
                                                                let base58 = l50;
                                                                let len58 = l51;
                                                                let mut result58 = _rt::Vec::with_capacity(len58);
                                                                for i in 0..len58 {
                                                                    let base = base58.add(i * 16);
                                                                    let e58 = {
                                                                        let l52 = *base.add(0).cast::<*mut u8>();
                                                                        let l53 = *base.add(4).cast::<usize>();
                                                                        let len54 = l53;
                                                                        let bytes54 = _rt::Vec::from_raw_parts(
                                                                            l52.cast(),
                                                                            len54,
                                                                            len54,
                                                                        );
                                                                        let l55 = *base.add(8).cast::<*mut u8>();
                                                                        let l56 = *base.add(12).cast::<usize>();
                                                                        let len57 = l56;
                                                                        let bytes57 = _rt::Vec::from_raw_parts(
                                                                            l55.cast(),
                                                                            len57,
                                                                            len57,
                                                                        );
                                                                        (_rt::string_lift(bytes54), _rt::string_lift(bytes57))
                                                                    };
                                                                    result58.push(e58);
                                                                }
                                                                _rt::cabi_dealloc(base58, len58 * 16, 4);
                                                                PluginInstallationDescription {
                                                                    installation_id: super::super::super::golem::api::host::Uuid {
                                                                        high_bits: l42 as u64,
                                                                        low_bits: l43 as u64,
                                                                    },
                                                                    name: _rt::string_lift(bytes46),
                                                                    version: _rt::string_lift(bytes49),
                                                                    parameters: result58,
                                                                }
                                                            };
                                                            result59.push(e59);
                                                        }
                                                        _rt::cabi_dealloc(base59, len59 * 40, 8);
                                                        CreateParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l6 as u64,
                                                                nanoseconds: l7 as u32,
                                                            },
                                                            worker_id: super::super::super::golem::api::host::WorkerId {
                                                                component_id: super::super::super::golem::api::host::ComponentId {
                                                                    uuid: super::super::super::golem::api::host::Uuid {
                                                                        high_bits: l8 as u64,
                                                                        low_bits: l9 as u64,
                                                                    },
                                                                },
                                                                worker_name: _rt::string_lift(bytes12),
                                                            },
                                                            component_version: l13 as u64,
                                                            args: result19,
                                                            env: result28,
                                                            account_id: super::super::super::golem::api::host::AccountId {
                                                                value: _rt::string_lift(bytes31),
                                                            },
                                                            parent: match l32 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l33 = *base.add(96).cast::<i64>();
                                                                        let l34 = *base.add(104).cast::<i64>();
                                                                        let l35 = *base.add(112).cast::<*mut u8>();
                                                                        let l36 = *base.add(116).cast::<usize>();
                                                                        let len37 = l36;
                                                                        let bytes37 = _rt::Vec::from_raw_parts(
                                                                            l35.cast(),
                                                                            len37,
                                                                            len37,
                                                                        );
                                                                        super::super::super::golem::api::host::WorkerId {
                                                                            component_id: super::super::super::golem::api::host::ComponentId {
                                                                                uuid: super::super::super::golem::api::host::Uuid {
                                                                                    high_bits: l33 as u64,
                                                                                    low_bits: l34 as u64,
                                                                                },
                                                                            },
                                                                            worker_name: _rt::string_lift(bytes37),
                                                                        }
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                            component_size: l38 as u64,
                                                            initial_total_linear_memory_size: l39 as u64,
                                                            initial_active_plugins: result59,
                                                        }
                                                    };
                                                    OplogEntry::Create(e621)
                                                }
                                                1 => {
                                                    let e621 = {
                                                        let l60 = *base.add(16).cast::<i64>();
                                                        let l61 = *base.add(24).cast::<i32>();
                                                        let l62 = *base.add(32).cast::<*mut u8>();
                                                        let l63 = *base.add(36).cast::<usize>();
                                                        let len64 = l63;
                                                        let bytes64 = _rt::Vec::from_raw_parts(
                                                            l62.cast(),
                                                            len64,
                                                            len64,
                                                        );
                                                        let l65 = *base.add(40).cast::<*mut u8>();
                                                        let l66 = *base.add(44).cast::<usize>();
                                                        let base112 = l65;
                                                        let len112 = l66;
                                                        let mut result112 = _rt::Vec::with_capacity(len112);
                                                        for i in 0..len112 {
                                                            let base = base112.add(i * 24);
                                                            let e112 = {
                                                                let l67 = i32::from(*base.add(0).cast::<u8>());
                                                                use super::super::super::golem::rpc::types::WitNode as V111;
                                                                let v111 = match l67 {
                                                                    0 => {
                                                                        let e111 = {
                                                                            let l68 = *base.add(8).cast::<*mut u8>();
                                                                            let l69 = *base.add(12).cast::<usize>();
                                                                            let len70 = l69;
                                                                            _rt::Vec::from_raw_parts(l68.cast(), len70, len70)
                                                                        };
                                                                        V111::RecordValue(e111)
                                                                    }
                                                                    1 => {
                                                                        let e111 = {
                                                                            let l71 = *base.add(8).cast::<i32>();
                                                                            let l72 = i32::from(*base.add(12).cast::<u8>());
                                                                            (
                                                                                l71 as u32,
                                                                                match l72 {
                                                                                    0 => None,
                                                                                    1 => {
                                                                                        let e = {
                                                                                            let l73 = *base.add(16).cast::<i32>();
                                                                                            l73
                                                                                        };
                                                                                        Some(e)
                                                                                    }
                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                },
                                                                            )
                                                                        };
                                                                        V111::VariantValue(e111)
                                                                    }
                                                                    2 => {
                                                                        let e111 = {
                                                                            let l74 = *base.add(8).cast::<i32>();
                                                                            l74 as u32
                                                                        };
                                                                        V111::EnumValue(e111)
                                                                    }
                                                                    3 => {
                                                                        let e111 = {
                                                                            let l75 = *base.add(8).cast::<*mut u8>();
                                                                            let l76 = *base.add(12).cast::<usize>();
                                                                            let base78 = l75;
                                                                            let len78 = l76;
                                                                            let mut result78 = _rt::Vec::with_capacity(len78);
                                                                            for i in 0..len78 {
                                                                                let base = base78.add(i * 1);
                                                                                let e78 = {
                                                                                    let l77 = i32::from(*base.add(0).cast::<u8>());
                                                                                    _rt::bool_lift(l77 as u8)
                                                                                };
                                                                                result78.push(e78);
                                                                            }
                                                                            _rt::cabi_dealloc(base78, len78 * 1, 1);
                                                                            result78
                                                                        };
                                                                        V111::FlagsValue(e111)
                                                                    }
                                                                    4 => {
                                                                        let e111 = {
                                                                            let l79 = *base.add(8).cast::<*mut u8>();
                                                                            let l80 = *base.add(12).cast::<usize>();
                                                                            let len81 = l80;
                                                                            _rt::Vec::from_raw_parts(l79.cast(), len81, len81)
                                                                        };
                                                                        V111::TupleValue(e111)
                                                                    }
                                                                    5 => {
                                                                        let e111 = {
                                                                            let l82 = *base.add(8).cast::<*mut u8>();
                                                                            let l83 = *base.add(12).cast::<usize>();
                                                                            let len84 = l83;
                                                                            _rt::Vec::from_raw_parts(l82.cast(), len84, len84)
                                                                        };
                                                                        V111::ListValue(e111)
                                                                    }
                                                                    6 => {
                                                                        let e111 = {
                                                                            let l85 = i32::from(*base.add(8).cast::<u8>());
                                                                            match l85 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l86 = *base.add(12).cast::<i32>();
                                                                                        l86
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            }
                                                                        };
                                                                        V111::OptionValue(e111)
                                                                    }
                                                                    7 => {
                                                                        let e111 = {
                                                                            let l87 = i32::from(*base.add(8).cast::<u8>());
                                                                            match l87 {
                                                                                0 => {
                                                                                    let e = {
                                                                                        let l88 = i32::from(*base.add(12).cast::<u8>());
                                                                                        match l88 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l89 = *base.add(16).cast::<i32>();
                                                                                                    l89
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        }
                                                                                    };
                                                                                    Ok(e)
                                                                                }
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l90 = i32::from(*base.add(12).cast::<u8>());
                                                                                        match l90 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l91 = *base.add(16).cast::<i32>();
                                                                                                    l91
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        }
                                                                                    };
                                                                                    Err(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            }
                                                                        };
                                                                        V111::ResultValue(e111)
                                                                    }
                                                                    8 => {
                                                                        let e111 = {
                                                                            let l92 = i32::from(*base.add(8).cast::<u8>());
                                                                            l92 as u8
                                                                        };
                                                                        V111::PrimU8(e111)
                                                                    }
                                                                    9 => {
                                                                        let e111 = {
                                                                            let l93 = i32::from(*base.add(8).cast::<u16>());
                                                                            l93 as u16
                                                                        };
                                                                        V111::PrimU16(e111)
                                                                    }
                                                                    10 => {
                                                                        let e111 = {
                                                                            let l94 = *base.add(8).cast::<i32>();
                                                                            l94 as u32
                                                                        };
                                                                        V111::PrimU32(e111)
                                                                    }
                                                                    11 => {
                                                                        let e111 = {
                                                                            let l95 = *base.add(8).cast::<i64>();
                                                                            l95 as u64
                                                                        };
                                                                        V111::PrimU64(e111)
                                                                    }
                                                                    12 => {
                                                                        let e111 = {
                                                                            let l96 = i32::from(*base.add(8).cast::<i8>());
                                                                            l96 as i8
                                                                        };
                                                                        V111::PrimS8(e111)
                                                                    }
                                                                    13 => {
                                                                        let e111 = {
                                                                            let l97 = i32::from(*base.add(8).cast::<i16>());
                                                                            l97 as i16
                                                                        };
                                                                        V111::PrimS16(e111)
                                                                    }
                                                                    14 => {
                                                                        let e111 = {
                                                                            let l98 = *base.add(8).cast::<i32>();
                                                                            l98
                                                                        };
                                                                        V111::PrimS32(e111)
                                                                    }
                                                                    15 => {
                                                                        let e111 = {
                                                                            let l99 = *base.add(8).cast::<i64>();
                                                                            l99
                                                                        };
                                                                        V111::PrimS64(e111)
                                                                    }
                                                                    16 => {
                                                                        let e111 = {
                                                                            let l100 = *base.add(8).cast::<f32>();
                                                                            l100
                                                                        };
                                                                        V111::PrimFloat32(e111)
                                                                    }
                                                                    17 => {
                                                                        let e111 = {
                                                                            let l101 = *base.add(8).cast::<f64>();
                                                                            l101
                                                                        };
                                                                        V111::PrimFloat64(e111)
                                                                    }
                                                                    18 => {
                                                                        let e111 = {
                                                                            let l102 = *base.add(8).cast::<i32>();
                                                                            _rt::char_lift(l102 as u32)
                                                                        };
                                                                        V111::PrimChar(e111)
                                                                    }
                                                                    19 => {
                                                                        let e111 = {
                                                                            let l103 = i32::from(*base.add(8).cast::<u8>());
                                                                            _rt::bool_lift(l103 as u8)
                                                                        };
                                                                        V111::PrimBool(e111)
                                                                    }
                                                                    20 => {
                                                                        let e111 = {
                                                                            let l104 = *base.add(8).cast::<*mut u8>();
                                                                            let l105 = *base.add(12).cast::<usize>();
                                                                            let len106 = l105;
                                                                            let bytes106 = _rt::Vec::from_raw_parts(
                                                                                l104.cast(),
                                                                                len106,
                                                                                len106,
                                                                            );
                                                                            _rt::string_lift(bytes106)
                                                                        };
                                                                        V111::PrimString(e111)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 21, "invalid enum discriminant");
                                                                        let e111 = {
                                                                            let l107 = *base.add(8).cast::<*mut u8>();
                                                                            let l108 = *base.add(12).cast::<usize>();
                                                                            let len109 = l108;
                                                                            let bytes109 = _rt::Vec::from_raw_parts(
                                                                                l107.cast(),
                                                                                len109,
                                                                                len109,
                                                                            );
                                                                            let l110 = *base.add(16).cast::<i64>();
                                                                            (
                                                                                super::super::super::golem::rpc::types::Uri {
                                                                                    value: _rt::string_lift(bytes109),
                                                                                },
                                                                                l110 as u64,
                                                                            )
                                                                        };
                                                                        V111::Handle(e111)
                                                                    }
                                                                };
                                                                v111
                                                            };
                                                            result112.push(e112);
                                                        }
                                                        _rt::cabi_dealloc(base112, len112 * 24, 8);
                                                        let l113 = *base.add(48).cast::<*mut u8>();
                                                        let l114 = *base.add(52).cast::<usize>();
                                                        let base160 = l113;
                                                        let len160 = l114;
                                                        let mut result160 = _rt::Vec::with_capacity(len160);
                                                        for i in 0..len160 {
                                                            let base = base160.add(i * 24);
                                                            let e160 = {
                                                                let l115 = i32::from(*base.add(0).cast::<u8>());
                                                                use super::super::super::golem::rpc::types::WitNode as V159;
                                                                let v159 = match l115 {
                                                                    0 => {
                                                                        let e159 = {
                                                                            let l116 = *base.add(8).cast::<*mut u8>();
                                                                            let l117 = *base.add(12).cast::<usize>();
                                                                            let len118 = l117;
                                                                            _rt::Vec::from_raw_parts(l116.cast(), len118, len118)
                                                                        };
                                                                        V159::RecordValue(e159)
                                                                    }
                                                                    1 => {
                                                                        let e159 = {
                                                                            let l119 = *base.add(8).cast::<i32>();
                                                                            let l120 = i32::from(*base.add(12).cast::<u8>());
                                                                            (
                                                                                l119 as u32,
                                                                                match l120 {
                                                                                    0 => None,
                                                                                    1 => {
                                                                                        let e = {
                                                                                            let l121 = *base.add(16).cast::<i32>();
                                                                                            l121
                                                                                        };
                                                                                        Some(e)
                                                                                    }
                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                },
                                                                            )
                                                                        };
                                                                        V159::VariantValue(e159)
                                                                    }
                                                                    2 => {
                                                                        let e159 = {
                                                                            let l122 = *base.add(8).cast::<i32>();
                                                                            l122 as u32
                                                                        };
                                                                        V159::EnumValue(e159)
                                                                    }
                                                                    3 => {
                                                                        let e159 = {
                                                                            let l123 = *base.add(8).cast::<*mut u8>();
                                                                            let l124 = *base.add(12).cast::<usize>();
                                                                            let base126 = l123;
                                                                            let len126 = l124;
                                                                            let mut result126 = _rt::Vec::with_capacity(len126);
                                                                            for i in 0..len126 {
                                                                                let base = base126.add(i * 1);
                                                                                let e126 = {
                                                                                    let l125 = i32::from(*base.add(0).cast::<u8>());
                                                                                    _rt::bool_lift(l125 as u8)
                                                                                };
                                                                                result126.push(e126);
                                                                            }
                                                                            _rt::cabi_dealloc(base126, len126 * 1, 1);
                                                                            result126
                                                                        };
                                                                        V159::FlagsValue(e159)
                                                                    }
                                                                    4 => {
                                                                        let e159 = {
                                                                            let l127 = *base.add(8).cast::<*mut u8>();
                                                                            let l128 = *base.add(12).cast::<usize>();
                                                                            let len129 = l128;
                                                                            _rt::Vec::from_raw_parts(l127.cast(), len129, len129)
                                                                        };
                                                                        V159::TupleValue(e159)
                                                                    }
                                                                    5 => {
                                                                        let e159 = {
                                                                            let l130 = *base.add(8).cast::<*mut u8>();
                                                                            let l131 = *base.add(12).cast::<usize>();
                                                                            let len132 = l131;
                                                                            _rt::Vec::from_raw_parts(l130.cast(), len132, len132)
                                                                        };
                                                                        V159::ListValue(e159)
                                                                    }
                                                                    6 => {
                                                                        let e159 = {
                                                                            let l133 = i32::from(*base.add(8).cast::<u8>());
                                                                            match l133 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l134 = *base.add(12).cast::<i32>();
                                                                                        l134
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            }
                                                                        };
                                                                        V159::OptionValue(e159)
                                                                    }
                                                                    7 => {
                                                                        let e159 = {
                                                                            let l135 = i32::from(*base.add(8).cast::<u8>());
                                                                            match l135 {
                                                                                0 => {
                                                                                    let e = {
                                                                                        let l136 = i32::from(*base.add(12).cast::<u8>());
                                                                                        match l136 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l137 = *base.add(16).cast::<i32>();
                                                                                                    l137
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        }
                                                                                    };
                                                                                    Ok(e)
                                                                                }
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l138 = i32::from(*base.add(12).cast::<u8>());
                                                                                        match l138 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l139 = *base.add(16).cast::<i32>();
                                                                                                    l139
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        }
                                                                                    };
                                                                                    Err(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            }
                                                                        };
                                                                        V159::ResultValue(e159)
                                                                    }
                                                                    8 => {
                                                                        let e159 = {
                                                                            let l140 = i32::from(*base.add(8).cast::<u8>());
                                                                            l140 as u8
                                                                        };
                                                                        V159::PrimU8(e159)
                                                                    }
                                                                    9 => {
                                                                        let e159 = {
                                                                            let l141 = i32::from(*base.add(8).cast::<u16>());
                                                                            l141 as u16
                                                                        };
                                                                        V159::PrimU16(e159)
                                                                    }
                                                                    10 => {
                                                                        let e159 = {
                                                                            let l142 = *base.add(8).cast::<i32>();
                                                                            l142 as u32
                                                                        };
                                                                        V159::PrimU32(e159)
                                                                    }
                                                                    11 => {
                                                                        let e159 = {
                                                                            let l143 = *base.add(8).cast::<i64>();
                                                                            l143 as u64
                                                                        };
                                                                        V159::PrimU64(e159)
                                                                    }
                                                                    12 => {
                                                                        let e159 = {
                                                                            let l144 = i32::from(*base.add(8).cast::<i8>());
                                                                            l144 as i8
                                                                        };
                                                                        V159::PrimS8(e159)
                                                                    }
                                                                    13 => {
                                                                        let e159 = {
                                                                            let l145 = i32::from(*base.add(8).cast::<i16>());
                                                                            l145 as i16
                                                                        };
                                                                        V159::PrimS16(e159)
                                                                    }
                                                                    14 => {
                                                                        let e159 = {
                                                                            let l146 = *base.add(8).cast::<i32>();
                                                                            l146
                                                                        };
                                                                        V159::PrimS32(e159)
                                                                    }
                                                                    15 => {
                                                                        let e159 = {
                                                                            let l147 = *base.add(8).cast::<i64>();
                                                                            l147
                                                                        };
                                                                        V159::PrimS64(e159)
                                                                    }
                                                                    16 => {
                                                                        let e159 = {
                                                                            let l148 = *base.add(8).cast::<f32>();
                                                                            l148
                                                                        };
                                                                        V159::PrimFloat32(e159)
                                                                    }
                                                                    17 => {
                                                                        let e159 = {
                                                                            let l149 = *base.add(8).cast::<f64>();
                                                                            l149
                                                                        };
                                                                        V159::PrimFloat64(e159)
                                                                    }
                                                                    18 => {
                                                                        let e159 = {
                                                                            let l150 = *base.add(8).cast::<i32>();
                                                                            _rt::char_lift(l150 as u32)
                                                                        };
                                                                        V159::PrimChar(e159)
                                                                    }
                                                                    19 => {
                                                                        let e159 = {
                                                                            let l151 = i32::from(*base.add(8).cast::<u8>());
                                                                            _rt::bool_lift(l151 as u8)
                                                                        };
                                                                        V159::PrimBool(e159)
                                                                    }
                                                                    20 => {
                                                                        let e159 = {
                                                                            let l152 = *base.add(8).cast::<*mut u8>();
                                                                            let l153 = *base.add(12).cast::<usize>();
                                                                            let len154 = l153;
                                                                            let bytes154 = _rt::Vec::from_raw_parts(
                                                                                l152.cast(),
                                                                                len154,
                                                                                len154,
                                                                            );
                                                                            _rt::string_lift(bytes154)
                                                                        };
                                                                        V159::PrimString(e159)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 21, "invalid enum discriminant");
                                                                        let e159 = {
                                                                            let l155 = *base.add(8).cast::<*mut u8>();
                                                                            let l156 = *base.add(12).cast::<usize>();
                                                                            let len157 = l156;
                                                                            let bytes157 = _rt::Vec::from_raw_parts(
                                                                                l155.cast(),
                                                                                len157,
                                                                                len157,
                                                                            );
                                                                            let l158 = *base.add(16).cast::<i64>();
                                                                            (
                                                                                super::super::super::golem::rpc::types::Uri {
                                                                                    value: _rt::string_lift(bytes157),
                                                                                },
                                                                                l158 as u64,
                                                                            )
                                                                        };
                                                                        V159::Handle(e159)
                                                                    }
                                                                };
                                                                v159
                                                            };
                                                            result160.push(e160);
                                                        }
                                                        _rt::cabi_dealloc(base160, len160 * 24, 8);
                                                        let l161 = i32::from(*base.add(56).cast::<u8>());
                                                        let v164 = match l161 {
                                                            0 => WrappedFunctionType::ReadLocal,
                                                            1 => WrappedFunctionType::WriteLocal,
                                                            2 => WrappedFunctionType::ReadRemote,
                                                            3 => WrappedFunctionType::WriteRemote,
                                                            n => {
                                                                debug_assert_eq!(n, 4, "invalid enum discriminant");
                                                                let e164 = {
                                                                    let l162 = i32::from(*base.add(64).cast::<u8>());
                                                                    match l162 {
                                                                        0 => None,
                                                                        1 => {
                                                                            let e = {
                                                                                let l163 = *base.add(72).cast::<i64>();
                                                                                l163 as u64
                                                                            };
                                                                            Some(e)
                                                                        }
                                                                        _ => _rt::invalid_enum_discriminant(),
                                                                    }
                                                                };
                                                                WrappedFunctionType::WriteRemoteBatched(e164)
                                                            }
                                                        };
                                                        ImportedFunctionInvokedParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l60 as u64,
                                                                nanoseconds: l61 as u32,
                                                            },
                                                            function_name: _rt::string_lift(bytes64),
                                                            request: super::super::super::golem::rpc::types::WitValue {
                                                                nodes: result112,
                                                            },
                                                            response: super::super::super::golem::rpc::types::WitValue {
                                                                nodes: result160,
                                                            },
                                                            wrapped_function_type: v164,
                                                        }
                                                    };
                                                    OplogEntry::ImportedFunctionInvoked(e621)
                                                }
                                                2 => {
                                                    let e621 = {
                                                        let l165 = *base.add(16).cast::<i64>();
                                                        let l166 = *base.add(24).cast::<i32>();
                                                        let l167 = *base.add(32).cast::<*mut u8>();
                                                        let l168 = *base.add(36).cast::<usize>();
                                                        let len169 = l168;
                                                        let bytes169 = _rt::Vec::from_raw_parts(
                                                            l167.cast(),
                                                            len169,
                                                            len169,
                                                        );
                                                        let l170 = *base.add(40).cast::<*mut u8>();
                                                        let l171 = *base.add(44).cast::<usize>();
                                                        let base220 = l170;
                                                        let len220 = l171;
                                                        let mut result220 = _rt::Vec::with_capacity(len220);
                                                        for i in 0..len220 {
                                                            let base = base220.add(i * 8);
                                                            let e220 = {
                                                                let l172 = *base.add(0).cast::<*mut u8>();
                                                                let l173 = *base.add(4).cast::<usize>();
                                                                let base219 = l172;
                                                                let len219 = l173;
                                                                let mut result219 = _rt::Vec::with_capacity(len219);
                                                                for i in 0..len219 {
                                                                    let base = base219.add(i * 24);
                                                                    let e219 = {
                                                                        let l174 = i32::from(*base.add(0).cast::<u8>());
                                                                        use super::super::super::golem::rpc::types::WitNode as V218;
                                                                        let v218 = match l174 {
                                                                            0 => {
                                                                                let e218 = {
                                                                                    let l175 = *base.add(8).cast::<*mut u8>();
                                                                                    let l176 = *base.add(12).cast::<usize>();
                                                                                    let len177 = l176;
                                                                                    _rt::Vec::from_raw_parts(l175.cast(), len177, len177)
                                                                                };
                                                                                V218::RecordValue(e218)
                                                                            }
                                                                            1 => {
                                                                                let e218 = {
                                                                                    let l178 = *base.add(8).cast::<i32>();
                                                                                    let l179 = i32::from(*base.add(12).cast::<u8>());
                                                                                    (
                                                                                        l178 as u32,
                                                                                        match l179 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l180 = *base.add(16).cast::<i32>();
                                                                                                    l180
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        },
                                                                                    )
                                                                                };
                                                                                V218::VariantValue(e218)
                                                                            }
                                                                            2 => {
                                                                                let e218 = {
                                                                                    let l181 = *base.add(8).cast::<i32>();
                                                                                    l181 as u32
                                                                                };
                                                                                V218::EnumValue(e218)
                                                                            }
                                                                            3 => {
                                                                                let e218 = {
                                                                                    let l182 = *base.add(8).cast::<*mut u8>();
                                                                                    let l183 = *base.add(12).cast::<usize>();
                                                                                    let base185 = l182;
                                                                                    let len185 = l183;
                                                                                    let mut result185 = _rt::Vec::with_capacity(len185);
                                                                                    for i in 0..len185 {
                                                                                        let base = base185.add(i * 1);
                                                                                        let e185 = {
                                                                                            let l184 = i32::from(*base.add(0).cast::<u8>());
                                                                                            _rt::bool_lift(l184 as u8)
                                                                                        };
                                                                                        result185.push(e185);
                                                                                    }
                                                                                    _rt::cabi_dealloc(base185, len185 * 1, 1);
                                                                                    result185
                                                                                };
                                                                                V218::FlagsValue(e218)
                                                                            }
                                                                            4 => {
                                                                                let e218 = {
                                                                                    let l186 = *base.add(8).cast::<*mut u8>();
                                                                                    let l187 = *base.add(12).cast::<usize>();
                                                                                    let len188 = l187;
                                                                                    _rt::Vec::from_raw_parts(l186.cast(), len188, len188)
                                                                                };
                                                                                V218::TupleValue(e218)
                                                                            }
                                                                            5 => {
                                                                                let e218 = {
                                                                                    let l189 = *base.add(8).cast::<*mut u8>();
                                                                                    let l190 = *base.add(12).cast::<usize>();
                                                                                    let len191 = l190;
                                                                                    _rt::Vec::from_raw_parts(l189.cast(), len191, len191)
                                                                                };
                                                                                V218::ListValue(e218)
                                                                            }
                                                                            6 => {
                                                                                let e218 = {
                                                                                    let l192 = i32::from(*base.add(8).cast::<u8>());
                                                                                    match l192 {
                                                                                        0 => None,
                                                                                        1 => {
                                                                                            let e = {
                                                                                                let l193 = *base.add(12).cast::<i32>();
                                                                                                l193
                                                                                            };
                                                                                            Some(e)
                                                                                        }
                                                                                        _ => _rt::invalid_enum_discriminant(),
                                                                                    }
                                                                                };
                                                                                V218::OptionValue(e218)
                                                                            }
                                                                            7 => {
                                                                                let e218 = {
                                                                                    let l194 = i32::from(*base.add(8).cast::<u8>());
                                                                                    match l194 {
                                                                                        0 => {
                                                                                            let e = {
                                                                                                let l195 = i32::from(*base.add(12).cast::<u8>());
                                                                                                match l195 {
                                                                                                    0 => None,
                                                                                                    1 => {
                                                                                                        let e = {
                                                                                                            let l196 = *base.add(16).cast::<i32>();
                                                                                                            l196
                                                                                                        };
                                                                                                        Some(e)
                                                                                                    }
                                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                                }
                                                                                            };
                                                                                            Ok(e)
                                                                                        }
                                                                                        1 => {
                                                                                            let e = {
                                                                                                let l197 = i32::from(*base.add(12).cast::<u8>());
                                                                                                match l197 {
                                                                                                    0 => None,
                                                                                                    1 => {
                                                                                                        let e = {
                                                                                                            let l198 = *base.add(16).cast::<i32>();
                                                                                                            l198
                                                                                                        };
                                                                                                        Some(e)
                                                                                                    }
                                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                                }
                                                                                            };
                                                                                            Err(e)
                                                                                        }
                                                                                        _ => _rt::invalid_enum_discriminant(),
                                                                                    }
                                                                                };
                                                                                V218::ResultValue(e218)
                                                                            }
                                                                            8 => {
                                                                                let e218 = {
                                                                                    let l199 = i32::from(*base.add(8).cast::<u8>());
                                                                                    l199 as u8
                                                                                };
                                                                                V218::PrimU8(e218)
                                                                            }
                                                                            9 => {
                                                                                let e218 = {
                                                                                    let l200 = i32::from(*base.add(8).cast::<u16>());
                                                                                    l200 as u16
                                                                                };
                                                                                V218::PrimU16(e218)
                                                                            }
                                                                            10 => {
                                                                                let e218 = {
                                                                                    let l201 = *base.add(8).cast::<i32>();
                                                                                    l201 as u32
                                                                                };
                                                                                V218::PrimU32(e218)
                                                                            }
                                                                            11 => {
                                                                                let e218 = {
                                                                                    let l202 = *base.add(8).cast::<i64>();
                                                                                    l202 as u64
                                                                                };
                                                                                V218::PrimU64(e218)
                                                                            }
                                                                            12 => {
                                                                                let e218 = {
                                                                                    let l203 = i32::from(*base.add(8).cast::<i8>());
                                                                                    l203 as i8
                                                                                };
                                                                                V218::PrimS8(e218)
                                                                            }
                                                                            13 => {
                                                                                let e218 = {
                                                                                    let l204 = i32::from(*base.add(8).cast::<i16>());
                                                                                    l204 as i16
                                                                                };
                                                                                V218::PrimS16(e218)
                                                                            }
                                                                            14 => {
                                                                                let e218 = {
                                                                                    let l205 = *base.add(8).cast::<i32>();
                                                                                    l205
                                                                                };
                                                                                V218::PrimS32(e218)
                                                                            }
                                                                            15 => {
                                                                                let e218 = {
                                                                                    let l206 = *base.add(8).cast::<i64>();
                                                                                    l206
                                                                                };
                                                                                V218::PrimS64(e218)
                                                                            }
                                                                            16 => {
                                                                                let e218 = {
                                                                                    let l207 = *base.add(8).cast::<f32>();
                                                                                    l207
                                                                                };
                                                                                V218::PrimFloat32(e218)
                                                                            }
                                                                            17 => {
                                                                                let e218 = {
                                                                                    let l208 = *base.add(8).cast::<f64>();
                                                                                    l208
                                                                                };
                                                                                V218::PrimFloat64(e218)
                                                                            }
                                                                            18 => {
                                                                                let e218 = {
                                                                                    let l209 = *base.add(8).cast::<i32>();
                                                                                    _rt::char_lift(l209 as u32)
                                                                                };
                                                                                V218::PrimChar(e218)
                                                                            }
                                                                            19 => {
                                                                                let e218 = {
                                                                                    let l210 = i32::from(*base.add(8).cast::<u8>());
                                                                                    _rt::bool_lift(l210 as u8)
                                                                                };
                                                                                V218::PrimBool(e218)
                                                                            }
                                                                            20 => {
                                                                                let e218 = {
                                                                                    let l211 = *base.add(8).cast::<*mut u8>();
                                                                                    let l212 = *base.add(12).cast::<usize>();
                                                                                    let len213 = l212;
                                                                                    let bytes213 = _rt::Vec::from_raw_parts(
                                                                                        l211.cast(),
                                                                                        len213,
                                                                                        len213,
                                                                                    );
                                                                                    _rt::string_lift(bytes213)
                                                                                };
                                                                                V218::PrimString(e218)
                                                                            }
                                                                            n => {
                                                                                debug_assert_eq!(n, 21, "invalid enum discriminant");
                                                                                let e218 = {
                                                                                    let l214 = *base.add(8).cast::<*mut u8>();
                                                                                    let l215 = *base.add(12).cast::<usize>();
                                                                                    let len216 = l215;
                                                                                    let bytes216 = _rt::Vec::from_raw_parts(
                                                                                        l214.cast(),
                                                                                        len216,
                                                                                        len216,
                                                                                    );
                                                                                    let l217 = *base.add(16).cast::<i64>();
                                                                                    (
                                                                                        super::super::super::golem::rpc::types::Uri {
                                                                                            value: _rt::string_lift(bytes216),
                                                                                        },
                                                                                        l217 as u64,
                                                                                    )
                                                                                };
                                                                                V218::Handle(e218)
                                                                            }
                                                                        };
                                                                        v218
                                                                    };
                                                                    result219.push(e219);
                                                                }
                                                                _rt::cabi_dealloc(base219, len219 * 24, 8);
                                                                super::super::super::golem::rpc::types::WitValue {
                                                                    nodes: result219,
                                                                }
                                                            };
                                                            result220.push(e220);
                                                        }
                                                        _rt::cabi_dealloc(base220, len220 * 8, 4);
                                                        let l221 = *base.add(48).cast::<*mut u8>();
                                                        let l222 = *base.add(52).cast::<usize>();
                                                        let len223 = l222;
                                                        let bytes223 = _rt::Vec::from_raw_parts(
                                                            l221.cast(),
                                                            len223,
                                                            len223,
                                                        );
                                                        let l224 = *base.add(56).cast::<*mut u8>();
                                                        let l225 = *base.add(60).cast::<usize>();
                                                        let len226 = l225;
                                                        let bytes226 = _rt::Vec::from_raw_parts(
                                                            l224.cast(),
                                                            len226,
                                                            len226,
                                                        );
                                                        let l227 = *base.add(64).cast::<*mut u8>();
                                                        let l228 = *base.add(68).cast::<usize>();
                                                        let base232 = l227;
                                                        let len232 = l228;
                                                        let mut result232 = _rt::Vec::with_capacity(len232);
                                                        for i in 0..len232 {
                                                            let base = base232.add(i * 8);
                                                            let e232 = {
                                                                let l229 = *base.add(0).cast::<*mut u8>();
                                                                let l230 = *base.add(4).cast::<usize>();
                                                                let len231 = l230;
                                                                let bytes231 = _rt::Vec::from_raw_parts(
                                                                    l229.cast(),
                                                                    len231,
                                                                    len231,
                                                                );
                                                                _rt::string_lift(bytes231)
                                                            };
                                                            result232.push(e232);
                                                        }
                                                        _rt::cabi_dealloc(base232, len232 * 8, 4);
                                                        let l233 = *base.add(72).cast::<*mut u8>();
                                                        let l234 = *base.add(76).cast::<usize>();
                                                        let base266 = l233;
                                                        let len266 = l234;
                                                        let mut result266 = _rt::Vec::with_capacity(len266);
                                                        for i in 0..len266 {
                                                            let base = base266.add(i * 8);
                                                            let e266 = {
                                                                let l235 = *base.add(0).cast::<*mut u8>();
                                                                let l236 = *base.add(4).cast::<usize>();
                                                                let base265 = l235;
                                                                let len265 = l236;
                                                                let mut result265 = _rt::Vec::with_capacity(len265);
                                                                for i in 0..len265 {
                                                                    let base = base265.add(i * 80);
                                                                    let e265 = {
                                                                        let l237 = i32::from(*base.add(0).cast::<u8>());
                                                                        let v264 = match l237 {
                                                                            0 => {
                                                                                let e264 = {
                                                                                    let l238 = *base.add(8).cast::<*mut u8>();
                                                                                    let l239 = *base.add(12).cast::<usize>();
                                                                                    let len240 = l239;
                                                                                    let bytes240 = _rt::Vec::from_raw_parts(
                                                                                        l238.cast(),
                                                                                        len240,
                                                                                        len240,
                                                                                    );
                                                                                    let l241 = *base.add(16).cast::<i64>();
                                                                                    let l242 = *base.add(24).cast::<i32>();
                                                                                    let l243 = i32::from(*base.add(32).cast::<u8>());
                                                                                    let l247 = i32::from(*base.add(48).cast::<u8>());
                                                                                    let l249 = *base.add(64).cast::<*mut u8>();
                                                                                    let l250 = *base.add(68).cast::<usize>();
                                                                                    let base259 = l249;
                                                                                    let len259 = l250;
                                                                                    let mut result259 = _rt::Vec::with_capacity(len259);
                                                                                    for i in 0..len259 {
                                                                                        let base = base259.add(i * 20);
                                                                                        let e259 = {
                                                                                            let l251 = *base.add(0).cast::<*mut u8>();
                                                                                            let l252 = *base.add(4).cast::<usize>();
                                                                                            let len253 = l252;
                                                                                            let bytes253 = _rt::Vec::from_raw_parts(
                                                                                                l251.cast(),
                                                                                                len253,
                                                                                                len253,
                                                                                            );
                                                                                            let l254 = i32::from(*base.add(8).cast::<u8>());
                                                                                            use super::super::super::golem::api::context::AttributeValue as V258;
                                                                                            let v258 = match l254 {
                                                                                                n => {
                                                                                                    debug_assert_eq!(n, 0, "invalid enum discriminant");
                                                                                                    let e258 = {
                                                                                                        let l255 = *base.add(12).cast::<*mut u8>();
                                                                                                        let l256 = *base.add(16).cast::<usize>();
                                                                                                        let len257 = l256;
                                                                                                        let bytes257 = _rt::Vec::from_raw_parts(
                                                                                                            l255.cast(),
                                                                                                            len257,
                                                                                                            len257,
                                                                                                        );
                                                                                                        _rt::string_lift(bytes257)
                                                                                                    };
                                                                                                    V258::String(e258)
                                                                                                }
                                                                                            };
                                                                                            super::super::super::golem::api::context::Attribute {
                                                                                                key: _rt::string_lift(bytes253),
                                                                                                value: v258,
                                                                                            }
                                                                                        };
                                                                                        result259.push(e259);
                                                                                    }
                                                                                    _rt::cabi_dealloc(base259, len259 * 20, 4);
                                                                                    let l260 = i32::from(*base.add(72).cast::<u8>());
                                                                                    LocalSpanData {
                                                                                        span_id: _rt::string_lift(bytes240),
                                                                                        start: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                                            seconds: l241 as u64,
                                                                                            nanoseconds: l242 as u32,
                                                                                        },
                                                                                        parent: match l243 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l244 = *base.add(36).cast::<*mut u8>();
                                                                                                    let l245 = *base.add(40).cast::<usize>();
                                                                                                    let len246 = l245;
                                                                                                    let bytes246 = _rt::Vec::from_raw_parts(
                                                                                                        l244.cast(),
                                                                                                        len246,
                                                                                                        len246,
                                                                                                    );
                                                                                                    _rt::string_lift(bytes246)
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        },
                                                                                        linked_context: match l247 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l248 = *base.add(56).cast::<i64>();
                                                                                                    l248 as u64
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        },
                                                                                        attributes: result259,
                                                                                        inherited: _rt::bool_lift(l260 as u8),
                                                                                    }
                                                                                };
                                                                                SpanData::LocalSpan(e264)
                                                                            }
                                                                            n => {
                                                                                debug_assert_eq!(n, 1, "invalid enum discriminant");
                                                                                let e264 = {
                                                                                    let l261 = *base.add(8).cast::<*mut u8>();
                                                                                    let l262 = *base.add(12).cast::<usize>();
                                                                                    let len263 = l262;
                                                                                    let bytes263 = _rt::Vec::from_raw_parts(
                                                                                        l261.cast(),
                                                                                        len263,
                                                                                        len263,
                                                                                    );
                                                                                    ExternalSpanData {
                                                                                        span_id: _rt::string_lift(bytes263),
                                                                                    }
                                                                                };
                                                                                SpanData::ExternalSpan(e264)
                                                                            }
                                                                        };
                                                                        v264
                                                                    };
                                                                    result265.push(e265);
                                                                }
                                                                _rt::cabi_dealloc(base265, len265 * 80, 8);
                                                                result265
                                                            };
                                                            result266.push(e266);
                                                        }
                                                        _rt::cabi_dealloc(base266, len266 * 8, 4);
                                                        ExportedFunctionInvokedParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l165 as u64,
                                                                nanoseconds: l166 as u32,
                                                            },
                                                            function_name: _rt::string_lift(bytes169),
                                                            request: result220,
                                                            idempotency_key: _rt::string_lift(bytes223),
                                                            trace_id: _rt::string_lift(bytes226),
                                                            trace_states: result232,
                                                            invocation_context: result266,
                                                        }
                                                    };
                                                    OplogEntry::ExportedFunctionInvoked(e621)
                                                }
                                                3 => {
                                                    let e621 = {
                                                        let l267 = *base.add(16).cast::<i64>();
                                                        let l268 = *base.add(24).cast::<i32>();
                                                        let l269 = *base.add(32).cast::<*mut u8>();
                                                        let l270 = *base.add(36).cast::<usize>();
                                                        let base316 = l269;
                                                        let len316 = l270;
                                                        let mut result316 = _rt::Vec::with_capacity(len316);
                                                        for i in 0..len316 {
                                                            let base = base316.add(i * 24);
                                                            let e316 = {
                                                                let l271 = i32::from(*base.add(0).cast::<u8>());
                                                                use super::super::super::golem::rpc::types::WitNode as V315;
                                                                let v315 = match l271 {
                                                                    0 => {
                                                                        let e315 = {
                                                                            let l272 = *base.add(8).cast::<*mut u8>();
                                                                            let l273 = *base.add(12).cast::<usize>();
                                                                            let len274 = l273;
                                                                            _rt::Vec::from_raw_parts(l272.cast(), len274, len274)
                                                                        };
                                                                        V315::RecordValue(e315)
                                                                    }
                                                                    1 => {
                                                                        let e315 = {
                                                                            let l275 = *base.add(8).cast::<i32>();
                                                                            let l276 = i32::from(*base.add(12).cast::<u8>());
                                                                            (
                                                                                l275 as u32,
                                                                                match l276 {
                                                                                    0 => None,
                                                                                    1 => {
                                                                                        let e = {
                                                                                            let l277 = *base.add(16).cast::<i32>();
                                                                                            l277
                                                                                        };
                                                                                        Some(e)
                                                                                    }
                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                },
                                                                            )
                                                                        };
                                                                        V315::VariantValue(e315)
                                                                    }
                                                                    2 => {
                                                                        let e315 = {
                                                                            let l278 = *base.add(8).cast::<i32>();
                                                                            l278 as u32
                                                                        };
                                                                        V315::EnumValue(e315)
                                                                    }
                                                                    3 => {
                                                                        let e315 = {
                                                                            let l279 = *base.add(8).cast::<*mut u8>();
                                                                            let l280 = *base.add(12).cast::<usize>();
                                                                            let base282 = l279;
                                                                            let len282 = l280;
                                                                            let mut result282 = _rt::Vec::with_capacity(len282);
                                                                            for i in 0..len282 {
                                                                                let base = base282.add(i * 1);
                                                                                let e282 = {
                                                                                    let l281 = i32::from(*base.add(0).cast::<u8>());
                                                                                    _rt::bool_lift(l281 as u8)
                                                                                };
                                                                                result282.push(e282);
                                                                            }
                                                                            _rt::cabi_dealloc(base282, len282 * 1, 1);
                                                                            result282
                                                                        };
                                                                        V315::FlagsValue(e315)
                                                                    }
                                                                    4 => {
                                                                        let e315 = {
                                                                            let l283 = *base.add(8).cast::<*mut u8>();
                                                                            let l284 = *base.add(12).cast::<usize>();
                                                                            let len285 = l284;
                                                                            _rt::Vec::from_raw_parts(l283.cast(), len285, len285)
                                                                        };
                                                                        V315::TupleValue(e315)
                                                                    }
                                                                    5 => {
                                                                        let e315 = {
                                                                            let l286 = *base.add(8).cast::<*mut u8>();
                                                                            let l287 = *base.add(12).cast::<usize>();
                                                                            let len288 = l287;
                                                                            _rt::Vec::from_raw_parts(l286.cast(), len288, len288)
                                                                        };
                                                                        V315::ListValue(e315)
                                                                    }
                                                                    6 => {
                                                                        let e315 = {
                                                                            let l289 = i32::from(*base.add(8).cast::<u8>());
                                                                            match l289 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l290 = *base.add(12).cast::<i32>();
                                                                                        l290
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            }
                                                                        };
                                                                        V315::OptionValue(e315)
                                                                    }
                                                                    7 => {
                                                                        let e315 = {
                                                                            let l291 = i32::from(*base.add(8).cast::<u8>());
                                                                            match l291 {
                                                                                0 => {
                                                                                    let e = {
                                                                                        let l292 = i32::from(*base.add(12).cast::<u8>());
                                                                                        match l292 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l293 = *base.add(16).cast::<i32>();
                                                                                                    l293
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        }
                                                                                    };
                                                                                    Ok(e)
                                                                                }
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l294 = i32::from(*base.add(12).cast::<u8>());
                                                                                        match l294 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l295 = *base.add(16).cast::<i32>();
                                                                                                    l295
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        }
                                                                                    };
                                                                                    Err(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            }
                                                                        };
                                                                        V315::ResultValue(e315)
                                                                    }
                                                                    8 => {
                                                                        let e315 = {
                                                                            let l296 = i32::from(*base.add(8).cast::<u8>());
                                                                            l296 as u8
                                                                        };
                                                                        V315::PrimU8(e315)
                                                                    }
                                                                    9 => {
                                                                        let e315 = {
                                                                            let l297 = i32::from(*base.add(8).cast::<u16>());
                                                                            l297 as u16
                                                                        };
                                                                        V315::PrimU16(e315)
                                                                    }
                                                                    10 => {
                                                                        let e315 = {
                                                                            let l298 = *base.add(8).cast::<i32>();
                                                                            l298 as u32
                                                                        };
                                                                        V315::PrimU32(e315)
                                                                    }
                                                                    11 => {
                                                                        let e315 = {
                                                                            let l299 = *base.add(8).cast::<i64>();
                                                                            l299 as u64
                                                                        };
                                                                        V315::PrimU64(e315)
                                                                    }
                                                                    12 => {
                                                                        let e315 = {
                                                                            let l300 = i32::from(*base.add(8).cast::<i8>());
                                                                            l300 as i8
                                                                        };
                                                                        V315::PrimS8(e315)
                                                                    }
                                                                    13 => {
                                                                        let e315 = {
                                                                            let l301 = i32::from(*base.add(8).cast::<i16>());
                                                                            l301 as i16
                                                                        };
                                                                        V315::PrimS16(e315)
                                                                    }
                                                                    14 => {
                                                                        let e315 = {
                                                                            let l302 = *base.add(8).cast::<i32>();
                                                                            l302
                                                                        };
                                                                        V315::PrimS32(e315)
                                                                    }
                                                                    15 => {
                                                                        let e315 = {
                                                                            let l303 = *base.add(8).cast::<i64>();
                                                                            l303
                                                                        };
                                                                        V315::PrimS64(e315)
                                                                    }
                                                                    16 => {
                                                                        let e315 = {
                                                                            let l304 = *base.add(8).cast::<f32>();
                                                                            l304
                                                                        };
                                                                        V315::PrimFloat32(e315)
                                                                    }
                                                                    17 => {
                                                                        let e315 = {
                                                                            let l305 = *base.add(8).cast::<f64>();
                                                                            l305
                                                                        };
                                                                        V315::PrimFloat64(e315)
                                                                    }
                                                                    18 => {
                                                                        let e315 = {
                                                                            let l306 = *base.add(8).cast::<i32>();
                                                                            _rt::char_lift(l306 as u32)
                                                                        };
                                                                        V315::PrimChar(e315)
                                                                    }
                                                                    19 => {
                                                                        let e315 = {
                                                                            let l307 = i32::from(*base.add(8).cast::<u8>());
                                                                            _rt::bool_lift(l307 as u8)
                                                                        };
                                                                        V315::PrimBool(e315)
                                                                    }
                                                                    20 => {
                                                                        let e315 = {
                                                                            let l308 = *base.add(8).cast::<*mut u8>();
                                                                            let l309 = *base.add(12).cast::<usize>();
                                                                            let len310 = l309;
                                                                            let bytes310 = _rt::Vec::from_raw_parts(
                                                                                l308.cast(),
                                                                                len310,
                                                                                len310,
                                                                            );
                                                                            _rt::string_lift(bytes310)
                                                                        };
                                                                        V315::PrimString(e315)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 21, "invalid enum discriminant");
                                                                        let e315 = {
                                                                            let l311 = *base.add(8).cast::<*mut u8>();
                                                                            let l312 = *base.add(12).cast::<usize>();
                                                                            let len313 = l312;
                                                                            let bytes313 = _rt::Vec::from_raw_parts(
                                                                                l311.cast(),
                                                                                len313,
                                                                                len313,
                                                                            );
                                                                            let l314 = *base.add(16).cast::<i64>();
                                                                            (
                                                                                super::super::super::golem::rpc::types::Uri {
                                                                                    value: _rt::string_lift(bytes313),
                                                                                },
                                                                                l314 as u64,
                                                                            )
                                                                        };
                                                                        V315::Handle(e315)
                                                                    }
                                                                };
                                                                v315
                                                            };
                                                            result316.push(e316);
                                                        }
                                                        _rt::cabi_dealloc(base316, len316 * 24, 8);
                                                        let l317 = *base.add(40).cast::<i64>();
                                                        ExportedFunctionCompletedParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l267 as u64,
                                                                nanoseconds: l268 as u32,
                                                            },
                                                            response: super::super::super::golem::rpc::types::WitValue {
                                                                nodes: result316,
                                                            },
                                                            consumed_fuel: l317,
                                                        }
                                                    };
                                                    OplogEntry::ExportedFunctionCompleted(e621)
                                                }
                                                4 => {
                                                    let e621 = {
                                                        let l318 = *base.add(16).cast::<i64>();
                                                        let l319 = *base.add(24).cast::<i32>();
                                                        super::super::super::wasi::clocks::wall_clock::Datetime {
                                                            seconds: l318 as u64,
                                                            nanoseconds: l319 as u32,
                                                        }
                                                    };
                                                    OplogEntry::Suspend(e621)
                                                }
                                                5 => {
                                                    let e621 = {
                                                        let l320 = *base.add(16).cast::<i64>();
                                                        let l321 = *base.add(24).cast::<i32>();
                                                        let l322 = *base.add(32).cast::<*mut u8>();
                                                        let l323 = *base.add(36).cast::<usize>();
                                                        let len324 = l323;
                                                        let bytes324 = _rt::Vec::from_raw_parts(
                                                            l322.cast(),
                                                            len324,
                                                            len324,
                                                        );
                                                        ErrorParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l320 as u64,
                                                                nanoseconds: l321 as u32,
                                                            },
                                                            error: _rt::string_lift(bytes324),
                                                        }
                                                    };
                                                    OplogEntry::Error(e621)
                                                }
                                                6 => {
                                                    let e621 = {
                                                        let l325 = *base.add(16).cast::<i64>();
                                                        let l326 = *base.add(24).cast::<i32>();
                                                        super::super::super::wasi::clocks::wall_clock::Datetime {
                                                            seconds: l325 as u64,
                                                            nanoseconds: l326 as u32,
                                                        }
                                                    };
                                                    OplogEntry::NoOp(e621)
                                                }
                                                7 => {
                                                    let e621 = {
                                                        let l327 = *base.add(16).cast::<i64>();
                                                        let l328 = *base.add(24).cast::<i32>();
                                                        let l329 = *base.add(32).cast::<i64>();
                                                        let l330 = *base.add(40).cast::<i64>();
                                                        JumpParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l327 as u64,
                                                                nanoseconds: l328 as u32,
                                                            },
                                                            start: l329 as u64,
                                                            end: l330 as u64,
                                                        }
                                                    };
                                                    OplogEntry::Jump(e621)
                                                }
                                                8 => {
                                                    let e621 = {
                                                        let l331 = *base.add(16).cast::<i64>();
                                                        let l332 = *base.add(24).cast::<i32>();
                                                        super::super::super::wasi::clocks::wall_clock::Datetime {
                                                            seconds: l331 as u64,
                                                            nanoseconds: l332 as u32,
                                                        }
                                                    };
                                                    OplogEntry::Interrupted(e621)
                                                }
                                                9 => {
                                                    let e621 = {
                                                        let l333 = *base.add(16).cast::<i64>();
                                                        let l334 = *base.add(24).cast::<i32>();
                                                        super::super::super::wasi::clocks::wall_clock::Datetime {
                                                            seconds: l333 as u64,
                                                            nanoseconds: l334 as u32,
                                                        }
                                                    };
                                                    OplogEntry::Exited(e621)
                                                }
                                                10 => {
                                                    let e621 = {
                                                        let l335 = *base.add(16).cast::<i64>();
                                                        let l336 = *base.add(24).cast::<i32>();
                                                        let l337 = *base.add(32).cast::<i32>();
                                                        let l338 = *base.add(40).cast::<i64>();
                                                        let l339 = *base.add(48).cast::<i64>();
                                                        let l340 = *base.add(56).cast::<f64>();
                                                        let l341 = i32::from(*base.add(64).cast::<u8>());
                                                        ChangeRetryPolicyParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l335 as u64,
                                                                nanoseconds: l336 as u32,
                                                            },
                                                            retry_policy: super::super::super::golem::api::host::RetryPolicy {
                                                                max_attempts: l337 as u32,
                                                                min_delay: l338 as u64,
                                                                max_delay: l339 as u64,
                                                                multiplier: l340,
                                                                max_jitter_factor: match l341 {
                                                                    0 => None,
                                                                    1 => {
                                                                        let e = {
                                                                            let l342 = *base.add(72).cast::<f64>();
                                                                            l342
                                                                        };
                                                                        Some(e)
                                                                    }
                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                },
                                                            },
                                                        }
                                                    };
                                                    OplogEntry::ChangeRetryPolicy(e621)
                                                }
                                                11 => {
                                                    let e621 = {
                                                        let l343 = *base.add(16).cast::<i64>();
                                                        let l344 = *base.add(24).cast::<i32>();
                                                        super::super::super::wasi::clocks::wall_clock::Datetime {
                                                            seconds: l343 as u64,
                                                            nanoseconds: l344 as u32,
                                                        }
                                                    };
                                                    OplogEntry::BeginAtomicRegion(e621)
                                                }
                                                12 => {
                                                    let e621 = {
                                                        let l345 = *base.add(16).cast::<i64>();
                                                        let l346 = *base.add(24).cast::<i32>();
                                                        let l347 = *base.add(32).cast::<i64>();
                                                        EndAtomicRegionParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l345 as u64,
                                                                nanoseconds: l346 as u32,
                                                            },
                                                            begin_index: l347 as u64,
                                                        }
                                                    };
                                                    OplogEntry::EndAtomicRegion(e621)
                                                }
                                                13 => {
                                                    let e621 = {
                                                        let l348 = *base.add(16).cast::<i64>();
                                                        let l349 = *base.add(24).cast::<i32>();
                                                        super::super::super::wasi::clocks::wall_clock::Datetime {
                                                            seconds: l348 as u64,
                                                            nanoseconds: l349 as u32,
                                                        }
                                                    };
                                                    OplogEntry::BeginRemoteWrite(e621)
                                                }
                                                14 => {
                                                    let e621 = {
                                                        let l350 = *base.add(16).cast::<i64>();
                                                        let l351 = *base.add(24).cast::<i32>();
                                                        let l352 = *base.add(32).cast::<i64>();
                                                        EndRemoteWriteParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l350 as u64,
                                                                nanoseconds: l351 as u32,
                                                            },
                                                            begin_index: l352 as u64,
                                                        }
                                                    };
                                                    OplogEntry::EndRemoteWrite(e621)
                                                }
                                                15 => {
                                                    let e621 = {
                                                        let l353 = *base.add(16).cast::<i64>();
                                                        let l354 = *base.add(24).cast::<i32>();
                                                        let l355 = i32::from(*base.add(32).cast::<u8>());
                                                        let v415 = match l355 {
                                                            0 => {
                                                                let e415 = {
                                                                    let l356 = *base.add(40).cast::<*mut u8>();
                                                                    let l357 = *base.add(44).cast::<usize>();
                                                                    let len358 = l357;
                                                                    let bytes358 = _rt::Vec::from_raw_parts(
                                                                        l356.cast(),
                                                                        len358,
                                                                        len358,
                                                                    );
                                                                    let l359 = *base.add(48).cast::<*mut u8>();
                                                                    let l360 = *base.add(52).cast::<usize>();
                                                                    let len361 = l360;
                                                                    let bytes361 = _rt::Vec::from_raw_parts(
                                                                        l359.cast(),
                                                                        len361,
                                                                        len361,
                                                                    );
                                                                    let l362 = i32::from(*base.add(56).cast::<u8>());
                                                                    ExportedFunctionInvocationParameters {
                                                                        idempotency_key: _rt::string_lift(bytes358),
                                                                        function_name: _rt::string_lift(bytes361),
                                                                        input: match l362 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l363 = *base.add(60).cast::<*mut u8>();
                                                                                    let l364 = *base.add(64).cast::<usize>();
                                                                                    let base413 = l363;
                                                                                    let len413 = l364;
                                                                                    let mut result413 = _rt::Vec::with_capacity(len413);
                                                                                    for i in 0..len413 {
                                                                                        let base = base413.add(i * 8);
                                                                                        let e413 = {
                                                                                            let l365 = *base.add(0).cast::<*mut u8>();
                                                                                            let l366 = *base.add(4).cast::<usize>();
                                                                                            let base412 = l365;
                                                                                            let len412 = l366;
                                                                                            let mut result412 = _rt::Vec::with_capacity(len412);
                                                                                            for i in 0..len412 {
                                                                                                let base = base412.add(i * 24);
                                                                                                let e412 = {
                                                                                                    let l367 = i32::from(*base.add(0).cast::<u8>());
                                                                                                    use super::super::super::golem::rpc::types::WitNode as V411;
                                                                                                    let v411 = match l367 {
                                                                                                        0 => {
                                                                                                            let e411 = {
                                                                                                                let l368 = *base.add(8).cast::<*mut u8>();
                                                                                                                let l369 = *base.add(12).cast::<usize>();
                                                                                                                let len370 = l369;
                                                                                                                _rt::Vec::from_raw_parts(l368.cast(), len370, len370)
                                                                                                            };
                                                                                                            V411::RecordValue(e411)
                                                                                                        }
                                                                                                        1 => {
                                                                                                            let e411 = {
                                                                                                                let l371 = *base.add(8).cast::<i32>();
                                                                                                                let l372 = i32::from(*base.add(12).cast::<u8>());
                                                                                                                (
                                                                                                                    l371 as u32,
                                                                                                                    match l372 {
                                                                                                                        0 => None,
                                                                                                                        1 => {
                                                                                                                            let e = {
                                                                                                                                let l373 = *base.add(16).cast::<i32>();
                                                                                                                                l373
                                                                                                                            };
                                                                                                                            Some(e)
                                                                                                                        }
                                                                                                                        _ => _rt::invalid_enum_discriminant(),
                                                                                                                    },
                                                                                                                )
                                                                                                            };
                                                                                                            V411::VariantValue(e411)
                                                                                                        }
                                                                                                        2 => {
                                                                                                            let e411 = {
                                                                                                                let l374 = *base.add(8).cast::<i32>();
                                                                                                                l374 as u32
                                                                                                            };
                                                                                                            V411::EnumValue(e411)
                                                                                                        }
                                                                                                        3 => {
                                                                                                            let e411 = {
                                                                                                                let l375 = *base.add(8).cast::<*mut u8>();
                                                                                                                let l376 = *base.add(12).cast::<usize>();
                                                                                                                let base378 = l375;
                                                                                                                let len378 = l376;
                                                                                                                let mut result378 = _rt::Vec::with_capacity(len378);
                                                                                                                for i in 0..len378 {
                                                                                                                    let base = base378.add(i * 1);
                                                                                                                    let e378 = {
                                                                                                                        let l377 = i32::from(*base.add(0).cast::<u8>());
                                                                                                                        _rt::bool_lift(l377 as u8)
                                                                                                                    };
                                                                                                                    result378.push(e378);
                                                                                                                }
                                                                                                                _rt::cabi_dealloc(base378, len378 * 1, 1);
                                                                                                                result378
                                                                                                            };
                                                                                                            V411::FlagsValue(e411)
                                                                                                        }
                                                                                                        4 => {
                                                                                                            let e411 = {
                                                                                                                let l379 = *base.add(8).cast::<*mut u8>();
                                                                                                                let l380 = *base.add(12).cast::<usize>();
                                                                                                                let len381 = l380;
                                                                                                                _rt::Vec::from_raw_parts(l379.cast(), len381, len381)
                                                                                                            };
                                                                                                            V411::TupleValue(e411)
                                                                                                        }
                                                                                                        5 => {
                                                                                                            let e411 = {
                                                                                                                let l382 = *base.add(8).cast::<*mut u8>();
                                                                                                                let l383 = *base.add(12).cast::<usize>();
                                                                                                                let len384 = l383;
                                                                                                                _rt::Vec::from_raw_parts(l382.cast(), len384, len384)
                                                                                                            };
                                                                                                            V411::ListValue(e411)
                                                                                                        }
                                                                                                        6 => {
                                                                                                            let e411 = {
                                                                                                                let l385 = i32::from(*base.add(8).cast::<u8>());
                                                                                                                match l385 {
                                                                                                                    0 => None,
                                                                                                                    1 => {
                                                                                                                        let e = {
                                                                                                                            let l386 = *base.add(12).cast::<i32>();
                                                                                                                            l386
                                                                                                                        };
                                                                                                                        Some(e)
                                                                                                                    }
                                                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                                                }
                                                                                                            };
                                                                                                            V411::OptionValue(e411)
                                                                                                        }
                                                                                                        7 => {
                                                                                                            let e411 = {
                                                                                                                let l387 = i32::from(*base.add(8).cast::<u8>());
                                                                                                                match l387 {
                                                                                                                    0 => {
                                                                                                                        let e = {
                                                                                                                            let l388 = i32::from(*base.add(12).cast::<u8>());
                                                                                                                            match l388 {
                                                                                                                                0 => None,
                                                                                                                                1 => {
                                                                                                                                    let e = {
                                                                                                                                        let l389 = *base.add(16).cast::<i32>();
                                                                                                                                        l389
                                                                                                                                    };
                                                                                                                                    Some(e)
                                                                                                                                }
                                                                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                                                                            }
                                                                                                                        };
                                                                                                                        Ok(e)
                                                                                                                    }
                                                                                                                    1 => {
                                                                                                                        let e = {
                                                                                                                            let l390 = i32::from(*base.add(12).cast::<u8>());
                                                                                                                            match l390 {
                                                                                                                                0 => None,
                                                                                                                                1 => {
                                                                                                                                    let e = {
                                                                                                                                        let l391 = *base.add(16).cast::<i32>();
                                                                                                                                        l391
                                                                                                                                    };
                                                                                                                                    Some(e)
                                                                                                                                }
                                                                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                                                                            }
                                                                                                                        };
                                                                                                                        Err(e)
                                                                                                                    }
                                                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                                                }
                                                                                                            };
                                                                                                            V411::ResultValue(e411)
                                                                                                        }
                                                                                                        8 => {
                                                                                                            let e411 = {
                                                                                                                let l392 = i32::from(*base.add(8).cast::<u8>());
                                                                                                                l392 as u8
                                                                                                            };
                                                                                                            V411::PrimU8(e411)
                                                                                                        }
                                                                                                        9 => {
                                                                                                            let e411 = {
                                                                                                                let l393 = i32::from(*base.add(8).cast::<u16>());
                                                                                                                l393 as u16
                                                                                                            };
                                                                                                            V411::PrimU16(e411)
                                                                                                        }
                                                                                                        10 => {
                                                                                                            let e411 = {
                                                                                                                let l394 = *base.add(8).cast::<i32>();
                                                                                                                l394 as u32
                                                                                                            };
                                                                                                            V411::PrimU32(e411)
                                                                                                        }
                                                                                                        11 => {
                                                                                                            let e411 = {
                                                                                                                let l395 = *base.add(8).cast::<i64>();
                                                                                                                l395 as u64
                                                                                                            };
                                                                                                            V411::PrimU64(e411)
                                                                                                        }
                                                                                                        12 => {
                                                                                                            let e411 = {
                                                                                                                let l396 = i32::from(*base.add(8).cast::<i8>());
                                                                                                                l396 as i8
                                                                                                            };
                                                                                                            V411::PrimS8(e411)
                                                                                                        }
                                                                                                        13 => {
                                                                                                            let e411 = {
                                                                                                                let l397 = i32::from(*base.add(8).cast::<i16>());
                                                                                                                l397 as i16
                                                                                                            };
                                                                                                            V411::PrimS16(e411)
                                                                                                        }
                                                                                                        14 => {
                                                                                                            let e411 = {
                                                                                                                let l398 = *base.add(8).cast::<i32>();
                                                                                                                l398
                                                                                                            };
                                                                                                            V411::PrimS32(e411)
                                                                                                        }
                                                                                                        15 => {
                                                                                                            let e411 = {
                                                                                                                let l399 = *base.add(8).cast::<i64>();
                                                                                                                l399
                                                                                                            };
                                                                                                            V411::PrimS64(e411)
                                                                                                        }
                                                                                                        16 => {
                                                                                                            let e411 = {
                                                                                                                let l400 = *base.add(8).cast::<f32>();
                                                                                                                l400
                                                                                                            };
                                                                                                            V411::PrimFloat32(e411)
                                                                                                        }
                                                                                                        17 => {
                                                                                                            let e411 = {
                                                                                                                let l401 = *base.add(8).cast::<f64>();
                                                                                                                l401
                                                                                                            };
                                                                                                            V411::PrimFloat64(e411)
                                                                                                        }
                                                                                                        18 => {
                                                                                                            let e411 = {
                                                                                                                let l402 = *base.add(8).cast::<i32>();
                                                                                                                _rt::char_lift(l402 as u32)
                                                                                                            };
                                                                                                            V411::PrimChar(e411)
                                                                                                        }
                                                                                                        19 => {
                                                                                                            let e411 = {
                                                                                                                let l403 = i32::from(*base.add(8).cast::<u8>());
                                                                                                                _rt::bool_lift(l403 as u8)
                                                                                                            };
                                                                                                            V411::PrimBool(e411)
                                                                                                        }
                                                                                                        20 => {
                                                                                                            let e411 = {
                                                                                                                let l404 = *base.add(8).cast::<*mut u8>();
                                                                                                                let l405 = *base.add(12).cast::<usize>();
                                                                                                                let len406 = l405;
                                                                                                                let bytes406 = _rt::Vec::from_raw_parts(
                                                                                                                    l404.cast(),
                                                                                                                    len406,
                                                                                                                    len406,
                                                                                                                );
                                                                                                                _rt::string_lift(bytes406)
                                                                                                            };
                                                                                                            V411::PrimString(e411)
                                                                                                        }
                                                                                                        n => {
                                                                                                            debug_assert_eq!(n, 21, "invalid enum discriminant");
                                                                                                            let e411 = {
                                                                                                                let l407 = *base.add(8).cast::<*mut u8>();
                                                                                                                let l408 = *base.add(12).cast::<usize>();
                                                                                                                let len409 = l408;
                                                                                                                let bytes409 = _rt::Vec::from_raw_parts(
                                                                                                                    l407.cast(),
                                                                                                                    len409,
                                                                                                                    len409,
                                                                                                                );
                                                                                                                let l410 = *base.add(16).cast::<i64>();
                                                                                                                (
                                                                                                                    super::super::super::golem::rpc::types::Uri {
                                                                                                                        value: _rt::string_lift(bytes409),
                                                                                                                    },
                                                                                                                    l410 as u64,
                                                                                                                )
                                                                                                            };
                                                                                                            V411::Handle(e411)
                                                                                                        }
                                                                                                    };
                                                                                                    v411
                                                                                                };
                                                                                                result412.push(e412);
                                                                                            }
                                                                                            _rt::cabi_dealloc(base412, len412 * 24, 8);
                                                                                            super::super::super::golem::rpc::types::WitValue {
                                                                                                nodes: result412,
                                                                                            }
                                                                                        };
                                                                                        result413.push(e413);
                                                                                    }
                                                                                    _rt::cabi_dealloc(base413, len413 * 8, 4);
                                                                                    result413
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        },
                                                                    }
                                                                };
                                                                WorkerInvocation::ExportedFunction(e415)
                                                            }
                                                            n => {
                                                                debug_assert_eq!(n, 1, "invalid enum discriminant");
                                                                let e415 = {
                                                                    let l414 = *base.add(40).cast::<i64>();
                                                                    l414 as u64
                                                                };
                                                                WorkerInvocation::ManualUpdate(e415)
                                                            }
                                                        };
                                                        PendingWorkerInvocationParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l353 as u64,
                                                                nanoseconds: l354 as u32,
                                                            },
                                                            invocation: v415,
                                                        }
                                                    };
                                                    OplogEntry::PendingWorkerInvocation(e621)
                                                }
                                                16 => {
                                                    let e621 = {
                                                        let l416 = *base.add(16).cast::<i64>();
                                                        let l417 = *base.add(24).cast::<i32>();
                                                        let l418 = *base.add(32).cast::<i64>();
                                                        let l419 = i32::from(*base.add(40).cast::<u8>());
                                                        let v423 = match l419 {
                                                            0 => UpdateDescription::AutoUpdate,
                                                            n => {
                                                                debug_assert_eq!(n, 1, "invalid enum discriminant");
                                                                let e423 = {
                                                                    let l420 = *base.add(44).cast::<*mut u8>();
                                                                    let l421 = *base.add(48).cast::<usize>();
                                                                    let len422 = l421;
                                                                    _rt::Vec::from_raw_parts(l420.cast(), len422, len422)
                                                                };
                                                                UpdateDescription::SnapshotBased(e423)
                                                            }
                                                        };
                                                        PendingUpdateParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l416 as u64,
                                                                nanoseconds: l417 as u32,
                                                            },
                                                            target_version: l418 as u64,
                                                            update_description: v423,
                                                        }
                                                    };
                                                    OplogEntry::PendingUpdate(e621)
                                                }
                                                17 => {
                                                    let e621 = {
                                                        let l424 = *base.add(16).cast::<i64>();
                                                        let l425 = *base.add(24).cast::<i32>();
                                                        let l426 = *base.add(32).cast::<i64>();
                                                        let l427 = *base.add(40).cast::<i64>();
                                                        let l428 = *base.add(48).cast::<*mut u8>();
                                                        let l429 = *base.add(52).cast::<usize>();
                                                        let base447 = l428;
                                                        let len447 = l429;
                                                        let mut result447 = _rt::Vec::with_capacity(len447);
                                                        for i in 0..len447 {
                                                            let base = base447.add(i * 40);
                                                            let e447 = {
                                                                let l430 = *base.add(0).cast::<i64>();
                                                                let l431 = *base.add(8).cast::<i64>();
                                                                let l432 = *base.add(16).cast::<*mut u8>();
                                                                let l433 = *base.add(20).cast::<usize>();
                                                                let len434 = l433;
                                                                let bytes434 = _rt::Vec::from_raw_parts(
                                                                    l432.cast(),
                                                                    len434,
                                                                    len434,
                                                                );
                                                                let l435 = *base.add(24).cast::<*mut u8>();
                                                                let l436 = *base.add(28).cast::<usize>();
                                                                let len437 = l436;
                                                                let bytes437 = _rt::Vec::from_raw_parts(
                                                                    l435.cast(),
                                                                    len437,
                                                                    len437,
                                                                );
                                                                let l438 = *base.add(32).cast::<*mut u8>();
                                                                let l439 = *base.add(36).cast::<usize>();
                                                                let base446 = l438;
                                                                let len446 = l439;
                                                                let mut result446 = _rt::Vec::with_capacity(len446);
                                                                for i in 0..len446 {
                                                                    let base = base446.add(i * 16);
                                                                    let e446 = {
                                                                        let l440 = *base.add(0).cast::<*mut u8>();
                                                                        let l441 = *base.add(4).cast::<usize>();
                                                                        let len442 = l441;
                                                                        let bytes442 = _rt::Vec::from_raw_parts(
                                                                            l440.cast(),
                                                                            len442,
                                                                            len442,
                                                                        );
                                                                        let l443 = *base.add(8).cast::<*mut u8>();
                                                                        let l444 = *base.add(12).cast::<usize>();
                                                                        let len445 = l444;
                                                                        let bytes445 = _rt::Vec::from_raw_parts(
                                                                            l443.cast(),
                                                                            len445,
                                                                            len445,
                                                                        );
                                                                        (_rt::string_lift(bytes442), _rt::string_lift(bytes445))
                                                                    };
                                                                    result446.push(e446);
                                                                }
                                                                _rt::cabi_dealloc(base446, len446 * 16, 4);
                                                                PluginInstallationDescription {
                                                                    installation_id: super::super::super::golem::api::host::Uuid {
                                                                        high_bits: l430 as u64,
                                                                        low_bits: l431 as u64,
                                                                    },
                                                                    name: _rt::string_lift(bytes434),
                                                                    version: _rt::string_lift(bytes437),
                                                                    parameters: result446,
                                                                }
                                                            };
                                                            result447.push(e447);
                                                        }
                                                        _rt::cabi_dealloc(base447, len447 * 40, 8);
                                                        SuccessfulUpdateParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l424 as u64,
                                                                nanoseconds: l425 as u32,
                                                            },
                                                            target_version: l426 as u64,
                                                            new_component_size: l427 as u64,
                                                            new_active_plugins: result447,
                                                        }
                                                    };
                                                    OplogEntry::SuccessfulUpdate(e621)
                                                }
                                                18 => {
                                                    let e621 = {
                                                        let l448 = *base.add(16).cast::<i64>();
                                                        let l449 = *base.add(24).cast::<i32>();
                                                        let l450 = *base.add(32).cast::<i64>();
                                                        let l451 = i32::from(*base.add(40).cast::<u8>());
                                                        FailedUpdateParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l448 as u64,
                                                                nanoseconds: l449 as u32,
                                                            },
                                                            target_version: l450 as u64,
                                                            details: match l451 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l452 = *base.add(44).cast::<*mut u8>();
                                                                        let l453 = *base.add(48).cast::<usize>();
                                                                        let len454 = l453;
                                                                        let bytes454 = _rt::Vec::from_raw_parts(
                                                                            l452.cast(),
                                                                            len454,
                                                                            len454,
                                                                        );
                                                                        _rt::string_lift(bytes454)
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                        }
                                                    };
                                                    OplogEntry::FailedUpdate(e621)
                                                }
                                                19 => {
                                                    let e621 = {
                                                        let l455 = *base.add(16).cast::<i64>();
                                                        let l456 = *base.add(24).cast::<i32>();
                                                        let l457 = *base.add(32).cast::<i64>();
                                                        GrowMemoryParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l455 as u64,
                                                                nanoseconds: l456 as u32,
                                                            },
                                                            delta: l457 as u64,
                                                        }
                                                    };
                                                    OplogEntry::GrowMemory(e621)
                                                }
                                                20 => {
                                                    let e621 = {
                                                        let l458 = *base.add(16).cast::<i64>();
                                                        let l459 = *base.add(24).cast::<i32>();
                                                        let l460 = *base.add(32).cast::<i64>();
                                                        CreateResourceParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l458 as u64,
                                                                nanoseconds: l459 as u32,
                                                            },
                                                            resource_id: l460 as u64,
                                                        }
                                                    };
                                                    OplogEntry::CreateResource(e621)
                                                }
                                                21 => {
                                                    let e621 = {
                                                        let l461 = *base.add(16).cast::<i64>();
                                                        let l462 = *base.add(24).cast::<i32>();
                                                        let l463 = *base.add(32).cast::<i64>();
                                                        DropResourceParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l461 as u64,
                                                                nanoseconds: l462 as u32,
                                                            },
                                                            resource_id: l463 as u64,
                                                        }
                                                    };
                                                    OplogEntry::DropResource(e621)
                                                }
                                                22 => {
                                                    let e621 = {
                                                        let l464 = *base.add(16).cast::<i64>();
                                                        let l465 = *base.add(24).cast::<i32>();
                                                        let l466 = *base.add(32).cast::<i64>();
                                                        let l467 = *base.add(40).cast::<*mut u8>();
                                                        let l468 = *base.add(44).cast::<usize>();
                                                        let len469 = l468;
                                                        let bytes469 = _rt::Vec::from_raw_parts(
                                                            l467.cast(),
                                                            len469,
                                                            len469,
                                                        );
                                                        let l470 = *base.add(48).cast::<*mut u8>();
                                                        let l471 = *base.add(52).cast::<usize>();
                                                        let base520 = l470;
                                                        let len520 = l471;
                                                        let mut result520 = _rt::Vec::with_capacity(len520);
                                                        for i in 0..len520 {
                                                            let base = base520.add(i * 8);
                                                            let e520 = {
                                                                let l472 = *base.add(0).cast::<*mut u8>();
                                                                let l473 = *base.add(4).cast::<usize>();
                                                                let base519 = l472;
                                                                let len519 = l473;
                                                                let mut result519 = _rt::Vec::with_capacity(len519);
                                                                for i in 0..len519 {
                                                                    let base = base519.add(i * 24);
                                                                    let e519 = {
                                                                        let l474 = i32::from(*base.add(0).cast::<u8>());
                                                                        use super::super::super::golem::rpc::types::WitNode as V518;
                                                                        let v518 = match l474 {
                                                                            0 => {
                                                                                let e518 = {
                                                                                    let l475 = *base.add(8).cast::<*mut u8>();
                                                                                    let l476 = *base.add(12).cast::<usize>();
                                                                                    let len477 = l476;
                                                                                    _rt::Vec::from_raw_parts(l475.cast(), len477, len477)
                                                                                };
                                                                                V518::RecordValue(e518)
                                                                            }
                                                                            1 => {
                                                                                let e518 = {
                                                                                    let l478 = *base.add(8).cast::<i32>();
                                                                                    let l479 = i32::from(*base.add(12).cast::<u8>());
                                                                                    (
                                                                                        l478 as u32,
                                                                                        match l479 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l480 = *base.add(16).cast::<i32>();
                                                                                                    l480
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        },
                                                                                    )
                                                                                };
                                                                                V518::VariantValue(e518)
                                                                            }
                                                                            2 => {
                                                                                let e518 = {
                                                                                    let l481 = *base.add(8).cast::<i32>();
                                                                                    l481 as u32
                                                                                };
                                                                                V518::EnumValue(e518)
                                                                            }
                                                                            3 => {
                                                                                let e518 = {
                                                                                    let l482 = *base.add(8).cast::<*mut u8>();
                                                                                    let l483 = *base.add(12).cast::<usize>();
                                                                                    let base485 = l482;
                                                                                    let len485 = l483;
                                                                                    let mut result485 = _rt::Vec::with_capacity(len485);
                                                                                    for i in 0..len485 {
                                                                                        let base = base485.add(i * 1);
                                                                                        let e485 = {
                                                                                            let l484 = i32::from(*base.add(0).cast::<u8>());
                                                                                            _rt::bool_lift(l484 as u8)
                                                                                        };
                                                                                        result485.push(e485);
                                                                                    }
                                                                                    _rt::cabi_dealloc(base485, len485 * 1, 1);
                                                                                    result485
                                                                                };
                                                                                V518::FlagsValue(e518)
                                                                            }
                                                                            4 => {
                                                                                let e518 = {
                                                                                    let l486 = *base.add(8).cast::<*mut u8>();
                                                                                    let l487 = *base.add(12).cast::<usize>();
                                                                                    let len488 = l487;
                                                                                    _rt::Vec::from_raw_parts(l486.cast(), len488, len488)
                                                                                };
                                                                                V518::TupleValue(e518)
                                                                            }
                                                                            5 => {
                                                                                let e518 = {
                                                                                    let l489 = *base.add(8).cast::<*mut u8>();
                                                                                    let l490 = *base.add(12).cast::<usize>();
                                                                                    let len491 = l490;
                                                                                    _rt::Vec::from_raw_parts(l489.cast(), len491, len491)
                                                                                };
                                                                                V518::ListValue(e518)
                                                                            }
                                                                            6 => {
                                                                                let e518 = {
                                                                                    let l492 = i32::from(*base.add(8).cast::<u8>());
                                                                                    match l492 {
                                                                                        0 => None,
                                                                                        1 => {
                                                                                            let e = {
                                                                                                let l493 = *base.add(12).cast::<i32>();
                                                                                                l493
                                                                                            };
                                                                                            Some(e)
                                                                                        }
                                                                                        _ => _rt::invalid_enum_discriminant(),
                                                                                    }
                                                                                };
                                                                                V518::OptionValue(e518)
                                                                            }
                                                                            7 => {
                                                                                let e518 = {
                                                                                    let l494 = i32::from(*base.add(8).cast::<u8>());
                                                                                    match l494 {
                                                                                        0 => {
                                                                                            let e = {
                                                                                                let l495 = i32::from(*base.add(12).cast::<u8>());
                                                                                                match l495 {
                                                                                                    0 => None,
                                                                                                    1 => {
                                                                                                        let e = {
                                                                                                            let l496 = *base.add(16).cast::<i32>();
                                                                                                            l496
                                                                                                        };
                                                                                                        Some(e)
                                                                                                    }
                                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                                }
                                                                                            };
                                                                                            Ok(e)
                                                                                        }
                                                                                        1 => {
                                                                                            let e = {
                                                                                                let l497 = i32::from(*base.add(12).cast::<u8>());
                                                                                                match l497 {
                                                                                                    0 => None,
                                                                                                    1 => {
                                                                                                        let e = {
                                                                                                            let l498 = *base.add(16).cast::<i32>();
                                                                                                            l498
                                                                                                        };
                                                                                                        Some(e)
                                                                                                    }
                                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                                }
                                                                                            };
                                                                                            Err(e)
                                                                                        }
                                                                                        _ => _rt::invalid_enum_discriminant(),
                                                                                    }
                                                                                };
                                                                                V518::ResultValue(e518)
                                                                            }
                                                                            8 => {
                                                                                let e518 = {
                                                                                    let l499 = i32::from(*base.add(8).cast::<u8>());
                                                                                    l499 as u8
                                                                                };
                                                                                V518::PrimU8(e518)
                                                                            }
                                                                            9 => {
                                                                                let e518 = {
                                                                                    let l500 = i32::from(*base.add(8).cast::<u16>());
                                                                                    l500 as u16
                                                                                };
                                                                                V518::PrimU16(e518)
                                                                            }
                                                                            10 => {
                                                                                let e518 = {
                                                                                    let l501 = *base.add(8).cast::<i32>();
                                                                                    l501 as u32
                                                                                };
                                                                                V518::PrimU32(e518)
                                                                            }
                                                                            11 => {
                                                                                let e518 = {
                                                                                    let l502 = *base.add(8).cast::<i64>();
                                                                                    l502 as u64
                                                                                };
                                                                                V518::PrimU64(e518)
                                                                            }
                                                                            12 => {
                                                                                let e518 = {
                                                                                    let l503 = i32::from(*base.add(8).cast::<i8>());
                                                                                    l503 as i8
                                                                                };
                                                                                V518::PrimS8(e518)
                                                                            }
                                                                            13 => {
                                                                                let e518 = {
                                                                                    let l504 = i32::from(*base.add(8).cast::<i16>());
                                                                                    l504 as i16
                                                                                };
                                                                                V518::PrimS16(e518)
                                                                            }
                                                                            14 => {
                                                                                let e518 = {
                                                                                    let l505 = *base.add(8).cast::<i32>();
                                                                                    l505
                                                                                };
                                                                                V518::PrimS32(e518)
                                                                            }
                                                                            15 => {
                                                                                let e518 = {
                                                                                    let l506 = *base.add(8).cast::<i64>();
                                                                                    l506
                                                                                };
                                                                                V518::PrimS64(e518)
                                                                            }
                                                                            16 => {
                                                                                let e518 = {
                                                                                    let l507 = *base.add(8).cast::<f32>();
                                                                                    l507
                                                                                };
                                                                                V518::PrimFloat32(e518)
                                                                            }
                                                                            17 => {
                                                                                let e518 = {
                                                                                    let l508 = *base.add(8).cast::<f64>();
                                                                                    l508
                                                                                };
                                                                                V518::PrimFloat64(e518)
                                                                            }
                                                                            18 => {
                                                                                let e518 = {
                                                                                    let l509 = *base.add(8).cast::<i32>();
                                                                                    _rt::char_lift(l509 as u32)
                                                                                };
                                                                                V518::PrimChar(e518)
                                                                            }
                                                                            19 => {
                                                                                let e518 = {
                                                                                    let l510 = i32::from(*base.add(8).cast::<u8>());
                                                                                    _rt::bool_lift(l510 as u8)
                                                                                };
                                                                                V518::PrimBool(e518)
                                                                            }
                                                                            20 => {
                                                                                let e518 = {
                                                                                    let l511 = *base.add(8).cast::<*mut u8>();
                                                                                    let l512 = *base.add(12).cast::<usize>();
                                                                                    let len513 = l512;
                                                                                    let bytes513 = _rt::Vec::from_raw_parts(
                                                                                        l511.cast(),
                                                                                        len513,
                                                                                        len513,
                                                                                    );
                                                                                    _rt::string_lift(bytes513)
                                                                                };
                                                                                V518::PrimString(e518)
                                                                            }
                                                                            n => {
                                                                                debug_assert_eq!(n, 21, "invalid enum discriminant");
                                                                                let e518 = {
                                                                                    let l514 = *base.add(8).cast::<*mut u8>();
                                                                                    let l515 = *base.add(12).cast::<usize>();
                                                                                    let len516 = l515;
                                                                                    let bytes516 = _rt::Vec::from_raw_parts(
                                                                                        l514.cast(),
                                                                                        len516,
                                                                                        len516,
                                                                                    );
                                                                                    let l517 = *base.add(16).cast::<i64>();
                                                                                    (
                                                                                        super::super::super::golem::rpc::types::Uri {
                                                                                            value: _rt::string_lift(bytes516),
                                                                                        },
                                                                                        l517 as u64,
                                                                                    )
                                                                                };
                                                                                V518::Handle(e518)
                                                                            }
                                                                        };
                                                                        v518
                                                                    };
                                                                    result519.push(e519);
                                                                }
                                                                _rt::cabi_dealloc(base519, len519 * 24, 8);
                                                                super::super::super::golem::rpc::types::WitValue {
                                                                    nodes: result519,
                                                                }
                                                            };
                                                            result520.push(e520);
                                                        }
                                                        _rt::cabi_dealloc(base520, len520 * 8, 4);
                                                        DescribeResourceParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l464 as u64,
                                                                nanoseconds: l465 as u32,
                                                            },
                                                            resource_id: l466 as u64,
                                                            resource_name: _rt::string_lift(bytes469),
                                                            resource_params: result520,
                                                        }
                                                    };
                                                    OplogEntry::DescribeResource(e621)
                                                }
                                                23 => {
                                                    let e621 = {
                                                        let l521 = *base.add(16).cast::<i64>();
                                                        let l522 = *base.add(24).cast::<i32>();
                                                        let l523 = i32::from(*base.add(32).cast::<u8>());
                                                        let l524 = *base.add(36).cast::<*mut u8>();
                                                        let l525 = *base.add(40).cast::<usize>();
                                                        let len526 = l525;
                                                        let bytes526 = _rt::Vec::from_raw_parts(
                                                            l524.cast(),
                                                            len526,
                                                            len526,
                                                        );
                                                        let l527 = *base.add(44).cast::<*mut u8>();
                                                        let l528 = *base.add(48).cast::<usize>();
                                                        let len529 = l528;
                                                        let bytes529 = _rt::Vec::from_raw_parts(
                                                            l527.cast(),
                                                            len529,
                                                            len529,
                                                        );
                                                        LogParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l521 as u64,
                                                                nanoseconds: l522 as u32,
                                                            },
                                                            level: LogLevel::_lift(l523 as u8),
                                                            context: _rt::string_lift(bytes526),
                                                            message: _rt::string_lift(bytes529),
                                                        }
                                                    };
                                                    OplogEntry::Log(e621)
                                                }
                                                24 => {
                                                    let e621 = {
                                                        let l530 = *base.add(16).cast::<i64>();
                                                        let l531 = *base.add(24).cast::<i32>();
                                                        super::super::super::wasi::clocks::wall_clock::Datetime {
                                                            seconds: l530 as u64,
                                                            nanoseconds: l531 as u32,
                                                        }
                                                    };
                                                    OplogEntry::Restart(e621)
                                                }
                                                25 => {
                                                    let e621 = {
                                                        let l532 = *base.add(16).cast::<i64>();
                                                        let l533 = *base.add(24).cast::<i32>();
                                                        let l534 = *base.add(32).cast::<i64>();
                                                        let l535 = *base.add(40).cast::<i64>();
                                                        let l536 = *base.add(48).cast::<*mut u8>();
                                                        let l537 = *base.add(52).cast::<usize>();
                                                        let len538 = l537;
                                                        let bytes538 = _rt::Vec::from_raw_parts(
                                                            l536.cast(),
                                                            len538,
                                                            len538,
                                                        );
                                                        let l539 = *base.add(56).cast::<*mut u8>();
                                                        let l540 = *base.add(60).cast::<usize>();
                                                        let len541 = l540;
                                                        let bytes541 = _rt::Vec::from_raw_parts(
                                                            l539.cast(),
                                                            len541,
                                                            len541,
                                                        );
                                                        let l542 = *base.add(64).cast::<*mut u8>();
                                                        let l543 = *base.add(68).cast::<usize>();
                                                        let base550 = l542;
                                                        let len550 = l543;
                                                        let mut result550 = _rt::Vec::with_capacity(len550);
                                                        for i in 0..len550 {
                                                            let base = base550.add(i * 16);
                                                            let e550 = {
                                                                let l544 = *base.add(0).cast::<*mut u8>();
                                                                let l545 = *base.add(4).cast::<usize>();
                                                                let len546 = l545;
                                                                let bytes546 = _rt::Vec::from_raw_parts(
                                                                    l544.cast(),
                                                                    len546,
                                                                    len546,
                                                                );
                                                                let l547 = *base.add(8).cast::<*mut u8>();
                                                                let l548 = *base.add(12).cast::<usize>();
                                                                let len549 = l548;
                                                                let bytes549 = _rt::Vec::from_raw_parts(
                                                                    l547.cast(),
                                                                    len549,
                                                                    len549,
                                                                );
                                                                (_rt::string_lift(bytes546), _rt::string_lift(bytes549))
                                                            };
                                                            result550.push(e550);
                                                        }
                                                        _rt::cabi_dealloc(base550, len550 * 16, 4);
                                                        ActivatePluginParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l532 as u64,
                                                                nanoseconds: l533 as u32,
                                                            },
                                                            plugin: PluginInstallationDescription {
                                                                installation_id: super::super::super::golem::api::host::Uuid {
                                                                    high_bits: l534 as u64,
                                                                    low_bits: l535 as u64,
                                                                },
                                                                name: _rt::string_lift(bytes538),
                                                                version: _rt::string_lift(bytes541),
                                                                parameters: result550,
                                                            },
                                                        }
                                                    };
                                                    OplogEntry::ActivatePlugin(e621)
                                                }
                                                26 => {
                                                    let e621 = {
                                                        let l551 = *base.add(16).cast::<i64>();
                                                        let l552 = *base.add(24).cast::<i32>();
                                                        let l553 = *base.add(32).cast::<i64>();
                                                        let l554 = *base.add(40).cast::<i64>();
                                                        let l555 = *base.add(48).cast::<*mut u8>();
                                                        let l556 = *base.add(52).cast::<usize>();
                                                        let len557 = l556;
                                                        let bytes557 = _rt::Vec::from_raw_parts(
                                                            l555.cast(),
                                                            len557,
                                                            len557,
                                                        );
                                                        let l558 = *base.add(56).cast::<*mut u8>();
                                                        let l559 = *base.add(60).cast::<usize>();
                                                        let len560 = l559;
                                                        let bytes560 = _rt::Vec::from_raw_parts(
                                                            l558.cast(),
                                                            len560,
                                                            len560,
                                                        );
                                                        let l561 = *base.add(64).cast::<*mut u8>();
                                                        let l562 = *base.add(68).cast::<usize>();
                                                        let base569 = l561;
                                                        let len569 = l562;
                                                        let mut result569 = _rt::Vec::with_capacity(len569);
                                                        for i in 0..len569 {
                                                            let base = base569.add(i * 16);
                                                            let e569 = {
                                                                let l563 = *base.add(0).cast::<*mut u8>();
                                                                let l564 = *base.add(4).cast::<usize>();
                                                                let len565 = l564;
                                                                let bytes565 = _rt::Vec::from_raw_parts(
                                                                    l563.cast(),
                                                                    len565,
                                                                    len565,
                                                                );
                                                                let l566 = *base.add(8).cast::<*mut u8>();
                                                                let l567 = *base.add(12).cast::<usize>();
                                                                let len568 = l567;
                                                                let bytes568 = _rt::Vec::from_raw_parts(
                                                                    l566.cast(),
                                                                    len568,
                                                                    len568,
                                                                );
                                                                (_rt::string_lift(bytes565), _rt::string_lift(bytes568))
                                                            };
                                                            result569.push(e569);
                                                        }
                                                        _rt::cabi_dealloc(base569, len569 * 16, 4);
                                                        DeactivatePluginParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l551 as u64,
                                                                nanoseconds: l552 as u32,
                                                            },
                                                            plugin: PluginInstallationDescription {
                                                                installation_id: super::super::super::golem::api::host::Uuid {
                                                                    high_bits: l553 as u64,
                                                                    low_bits: l554 as u64,
                                                                },
                                                                name: _rt::string_lift(bytes557),
                                                                version: _rt::string_lift(bytes560),
                                                                parameters: result569,
                                                            },
                                                        }
                                                    };
                                                    OplogEntry::DeactivatePlugin(e621)
                                                }
                                                27 => {
                                                    let e621 = {
                                                        let l570 = *base.add(16).cast::<i64>();
                                                        let l571 = *base.add(24).cast::<i32>();
                                                        let l572 = *base.add(32).cast::<i64>();
                                                        let l573 = *base.add(40).cast::<i64>();
                                                        RevertParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l570 as u64,
                                                                nanoseconds: l571 as u32,
                                                            },
                                                            start: l572 as u64,
                                                            end: l573 as u64,
                                                        }
                                                    };
                                                    OplogEntry::Revert(e621)
                                                }
                                                28 => {
                                                    let e621 = {
                                                        let l574 = *base.add(16).cast::<i64>();
                                                        let l575 = *base.add(24).cast::<i32>();
                                                        let l576 = *base.add(32).cast::<*mut u8>();
                                                        let l577 = *base.add(36).cast::<usize>();
                                                        let len578 = l577;
                                                        let bytes578 = _rt::Vec::from_raw_parts(
                                                            l576.cast(),
                                                            len578,
                                                            len578,
                                                        );
                                                        CancelInvocationParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l574 as u64,
                                                                nanoseconds: l575 as u32,
                                                            },
                                                            idempotency_key: _rt::string_lift(bytes578),
                                                        }
                                                    };
                                                    OplogEntry::CancelInvocation(e621)
                                                }
                                                29 => {
                                                    let e621 = {
                                                        let l579 = *base.add(16).cast::<i64>();
                                                        let l580 = *base.add(24).cast::<i32>();
                                                        let l581 = *base.add(32).cast::<*mut u8>();
                                                        let l582 = *base.add(36).cast::<usize>();
                                                        let len583 = l582;
                                                        let bytes583 = _rt::Vec::from_raw_parts(
                                                            l581.cast(),
                                                            len583,
                                                            len583,
                                                        );
                                                        let l584 = i32::from(*base.add(40).cast::<u8>());
                                                        let l588 = i32::from(*base.add(52).cast::<u8>());
                                                        let l592 = *base.add(64).cast::<*mut u8>();
                                                        let l593 = *base.add(68).cast::<usize>();
                                                        let base602 = l592;
                                                        let len602 = l593;
                                                        let mut result602 = _rt::Vec::with_capacity(len602);
                                                        for i in 0..len602 {
                                                            let base = base602.add(i * 20);
                                                            let e602 = {
                                                                let l594 = *base.add(0).cast::<*mut u8>();
                                                                let l595 = *base.add(4).cast::<usize>();
                                                                let len596 = l595;
                                                                let bytes596 = _rt::Vec::from_raw_parts(
                                                                    l594.cast(),
                                                                    len596,
                                                                    len596,
                                                                );
                                                                let l597 = i32::from(*base.add(8).cast::<u8>());
                                                                use super::super::super::golem::api::context::AttributeValue as V601;
                                                                let v601 = match l597 {
                                                                    n => {
                                                                        debug_assert_eq!(n, 0, "invalid enum discriminant");
                                                                        let e601 = {
                                                                            let l598 = *base.add(12).cast::<*mut u8>();
                                                                            let l599 = *base.add(16).cast::<usize>();
                                                                            let len600 = l599;
                                                                            let bytes600 = _rt::Vec::from_raw_parts(
                                                                                l598.cast(),
                                                                                len600,
                                                                                len600,
                                                                            );
                                                                            _rt::string_lift(bytes600)
                                                                        };
                                                                        V601::String(e601)
                                                                    }
                                                                };
                                                                super::super::super::golem::api::context::Attribute {
                                                                    key: _rt::string_lift(bytes596),
                                                                    value: v601,
                                                                }
                                                            };
                                                            result602.push(e602);
                                                        }
                                                        _rt::cabi_dealloc(base602, len602 * 20, 4);
                                                        StartSpanParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l579 as u64,
                                                                nanoseconds: l580 as u32,
                                                            },
                                                            span_id: _rt::string_lift(bytes583),
                                                            parent: match l584 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l585 = *base.add(44).cast::<*mut u8>();
                                                                        let l586 = *base.add(48).cast::<usize>();
                                                                        let len587 = l586;
                                                                        let bytes587 = _rt::Vec::from_raw_parts(
                                                                            l585.cast(),
                                                                            len587,
                                                                            len587,
                                                                        );
                                                                        _rt::string_lift(bytes587)
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                            linked_context: match l588 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l589 = *base.add(56).cast::<*mut u8>();
                                                                        let l590 = *base.add(60).cast::<usize>();
                                                                        let len591 = l590;
                                                                        let bytes591 = _rt::Vec::from_raw_parts(
                                                                            l589.cast(),
                                                                            len591,
                                                                            len591,
                                                                        );
                                                                        _rt::string_lift(bytes591)
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                            attributes: result602,
                                                        }
                                                    };
                                                    OplogEntry::StartSpan(e621)
                                                }
                                                30 => {
                                                    let e621 = {
                                                        let l603 = *base.add(16).cast::<i64>();
                                                        let l604 = *base.add(24).cast::<i32>();
                                                        let l605 = *base.add(32).cast::<*mut u8>();
                                                        let l606 = *base.add(36).cast::<usize>();
                                                        let len607 = l606;
                                                        let bytes607 = _rt::Vec::from_raw_parts(
                                                            l605.cast(),
                                                            len607,
                                                            len607,
                                                        );
                                                        FinishSpanParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l603 as u64,
                                                                nanoseconds: l604 as u32,
                                                            },
                                                            span_id: _rt::string_lift(bytes607),
                                                        }
                                                    };
                                                    OplogEntry::FinishSpan(e621)
                                                }
                                                n => {
                                                    debug_assert_eq!(n, 31, "invalid enum discriminant");
                                                    let e621 = {
                                                        let l608 = *base.add(16).cast::<i64>();
                                                        let l609 = *base.add(24).cast::<i32>();
                                                        let l610 = *base.add(32).cast::<*mut u8>();
                                                        let l611 = *base.add(36).cast::<usize>();
                                                        let len612 = l611;
                                                        let bytes612 = _rt::Vec::from_raw_parts(
                                                            l610.cast(),
                                                            len612,
                                                            len612,
                                                        );
                                                        let l613 = *base.add(40).cast::<*mut u8>();
                                                        let l614 = *base.add(44).cast::<usize>();
                                                        let len615 = l614;
                                                        let bytes615 = _rt::Vec::from_raw_parts(
                                                            l613.cast(),
                                                            len615,
                                                            len615,
                                                        );
                                                        let l616 = i32::from(*base.add(48).cast::<u8>());
                                                        use super::super::super::golem::api::context::AttributeValue as V620;
                                                        let v620 = match l616 {
                                                            n => {
                                                                debug_assert_eq!(n, 0, "invalid enum discriminant");
                                                                let e620 = {
                                                                    let l617 = *base.add(52).cast::<*mut u8>();
                                                                    let l618 = *base.add(56).cast::<usize>();
                                                                    let len619 = l618;
                                                                    let bytes619 = _rt::Vec::from_raw_parts(
                                                                        l617.cast(),
                                                                        len619,
                                                                        len619,
                                                                    );
                                                                    _rt::string_lift(bytes619)
                                                                };
                                                                V620::String(e620)
                                                            }
                                                        };
                                                        SetSpanAttributeParameters {
                                                            timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                                                                seconds: l608 as u64,
                                                                nanoseconds: l609 as u32,
                                                            },
                                                            span_id: _rt::string_lift(bytes612),
                                                            key: _rt::string_lift(bytes615),
                                                            value: v620,
                                                        }
                                                    };
                                                    OplogEntry::SetSpanAttribute(e621)
                                                }
                                            };
                                            (l4 as u64, v621)
                                        };
                                        result622.push(e622);
                                    }
                                    _rt::cabi_dealloc(base622, len622 * 144, 8);
                                    result622
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
        }
    }
    pub mod durability {
        #[allow(dead_code, clippy::all)]
        pub mod durability {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            use super::super::super::_rt;
            pub type PersistenceLevel = super::super::super::golem::api::host::PersistenceLevel;
            pub type OplogIndex = super::super::super::golem::api::oplog::OplogIndex;
            pub type WrappedFunctionType = super::super::super::golem::api::oplog::WrappedFunctionType;
            pub type Datetime = super::super::super::wasi::clocks::wall_clock::Datetime;
            pub type ValueAndType = super::super::super::golem::rpc::types::ValueAndType;
            pub type DurableFunctionType = WrappedFunctionType;
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct DurableExecutionState {
                pub is_live: bool,
                pub persistence_level: PersistenceLevel,
            }
            impl ::core::fmt::Debug for DurableExecutionState {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("DurableExecutionState")
                        .field("is-live", &self.is_live)
                        .field("persistence-level", &self.persistence_level)
                        .finish()
                }
            }
            #[repr(u8)]
            #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
            pub enum OplogEntryVersion {
                V1,
                V2,
            }
            impl ::core::fmt::Debug for OplogEntryVersion {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        OplogEntryVersion::V1 => {
                            f.debug_tuple("OplogEntryVersion::V1").finish()
                        }
                        OplogEntryVersion::V2 => {
                            f.debug_tuple("OplogEntryVersion::V2").finish()
                        }
                    }
                }
            }
            impl OplogEntryVersion {
                #[doc(hidden)]
                pub unsafe fn _lift(val: u8) -> OplogEntryVersion {
                    if !cfg!(debug_assertions) {
                        return ::core::mem::transmute(val);
                    }
                    match val {
                        0 => OplogEntryVersion::V1,
                        1 => OplogEntryVersion::V2,
                        _ => panic!("invalid enum discriminant"),
                    }
                }
            }
            #[derive(Clone)]
            pub struct PersistedDurableFunctionInvocation {
                pub timestamp: Datetime,
                pub function_name: _rt::String,
                pub response: _rt::Vec<u8>,
                pub function_type: DurableFunctionType,
                pub entry_version: OplogEntryVersion,
            }
            impl ::core::fmt::Debug for PersistedDurableFunctionInvocation {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("PersistedDurableFunctionInvocation")
                        .field("timestamp", &self.timestamp)
                        .field("function-name", &self.function_name)
                        .field("response", &self.response)
                        .field("function-type", &self.function_type)
                        .field("entry-version", &self.entry_version)
                        .finish()
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Observes a function call (produces logs and metrics)
            pub fn observe_function_call(iface: &str, function: &str) {
                unsafe {
                    let vec0 = iface;
                    let ptr0 = vec0.as_ptr().cast::<u8>();
                    let len0 = vec0.len();
                    let vec1 = function;
                    let ptr1 = vec1.as_ptr().cast::<u8>();
                    let len1 = vec1.len();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:durability/durability@1.2.0")]
                    extern "C" {
                        #[link_name = "observe-function-call"]
                        fn wit_import(_: *mut u8, _: usize, _: *mut u8, _: usize);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: *mut u8, _: usize, _: *mut u8, _: usize) {
                        unreachable!()
                    }
                    wit_import(ptr0.cast_mut(), len0, ptr1.cast_mut(), len1);
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Marks the beginning of a durable function.
            ///
            /// There must be a corresponding call to `end-durable-function` after the function has
            /// performed its work (it can be ended in a different context, for example after an async
            /// pollable operation has been completed)
            pub fn begin_durable_function(
                function_type: DurableFunctionType,
            ) -> OplogIndex {
                unsafe {
                    use super::super::super::golem::api::oplog::WrappedFunctionType as V1;
                    let (result2_0, result2_1, result2_2) = match function_type {
                        V1::ReadLocal => (0i32, 0i32, 0i64),
                        V1::WriteLocal => (1i32, 0i32, 0i64),
                        V1::ReadRemote => (2i32, 0i32, 0i64),
                        V1::WriteRemote => (3i32, 0i32, 0i64),
                        V1::WriteRemoteBatched(e) => {
                            let (result0_0, result0_1) = match e {
                                Some(e) => (1i32, _rt::as_i64(e)),
                                None => (0i32, 0i64),
                            };
                            (4i32, result0_0, result0_1)
                        }
                    };
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:durability/durability@1.2.0")]
                    extern "C" {
                        #[link_name = "begin-durable-function"]
                        fn wit_import(_: i32, _: i32, _: i64) -> i64;
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i32, _: i32, _: i64) -> i64 {
                        unreachable!()
                    }
                    let ret = wit_import(result2_0, result2_1, result2_2);
                    ret as u64
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Marks the end of a durable function
            ///
            /// This is a pair of `begin-durable-function` and should be called after the durable function
            /// has performed and persisted or replayed its work. The `begin-index` should be the index
            /// returned by `begin-durable-function`.
            ///
            /// Normally commit behavior is decided by the executor based on the `function-type`. However, in special
            /// cases the `forced-commit` parameter can be used to force commit the oplog in an efficient way.
            pub fn end_durable_function(
                function_type: DurableFunctionType,
                begin_index: OplogIndex,
                forced_commit: bool,
            ) {
                unsafe {
                    use super::super::super::golem::api::oplog::WrappedFunctionType as V1;
                    let (result2_0, result2_1, result2_2) = match function_type {
                        V1::ReadLocal => (0i32, 0i32, 0i64),
                        V1::WriteLocal => (1i32, 0i32, 0i64),
                        V1::ReadRemote => (2i32, 0i32, 0i64),
                        V1::WriteRemote => (3i32, 0i32, 0i64),
                        V1::WriteRemoteBatched(e) => {
                            let (result0_0, result0_1) = match e {
                                Some(e) => (1i32, _rt::as_i64(e)),
                                None => (0i32, 0i64),
                            };
                            (4i32, result0_0, result0_1)
                        }
                    };
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:durability/durability@1.2.0")]
                    extern "C" {
                        #[link_name = "end-durable-function"]
                        fn wit_import(_: i32, _: i32, _: i64, _: i64, _: i32);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i32, _: i32, _: i64, _: i64, _: i32) {
                        unreachable!()
                    }
                    wit_import(
                        result2_0,
                        result2_1,
                        result2_2,
                        _rt::as_i64(begin_index),
                        match &forced_commit {
                            true => 1,
                            false => 0,
                        },
                    );
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Gets the current durable execution state
            pub fn current_durable_execution_state() -> DurableExecutionState {
                unsafe {
                    #[repr(align(1))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 2]);
                    let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:durability/durability@1.2.0")]
                    extern "C" {
                        #[link_name = "current-durable-execution-state"]
                        fn wit_import(_: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: *mut u8) {
                        unreachable!()
                    }
                    wit_import(ptr0);
                    let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                    let l2 = i32::from(*ptr0.add(1).cast::<u8>());
                    use super::super::super::golem::api::host::PersistenceLevel as V3;
                    let v3 = match l2 {
                        0 => V3::PersistNothing,
                        1 => V3::PersistRemoteSideEffects,
                        n => {
                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                            V3::Smart
                        }
                    };
                    DurableExecutionState {
                        is_live: _rt::bool_lift(l1 as u8),
                        persistence_level: v3,
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Writes a record to the worker's oplog representing a durable function invocation
            pub fn persist_durable_function_invocation(
                function_name: &str,
                request: &[u8],
                response: &[u8],
                function_type: DurableFunctionType,
            ) {
                unsafe {
                    let vec0 = function_name;
                    let ptr0 = vec0.as_ptr().cast::<u8>();
                    let len0 = vec0.len();
                    let vec1 = request;
                    let ptr1 = vec1.as_ptr().cast::<u8>();
                    let len1 = vec1.len();
                    let vec2 = response;
                    let ptr2 = vec2.as_ptr().cast::<u8>();
                    let len2 = vec2.len();
                    use super::super::super::golem::api::oplog::WrappedFunctionType as V4;
                    let (result5_0, result5_1, result5_2) = match function_type {
                        V4::ReadLocal => (0i32, 0i32, 0i64),
                        V4::WriteLocal => (1i32, 0i32, 0i64),
                        V4::ReadRemote => (2i32, 0i32, 0i64),
                        V4::WriteRemote => (3i32, 0i32, 0i64),
                        V4::WriteRemoteBatched(e) => {
                            let (result3_0, result3_1) = match e {
                                Some(e) => (1i32, _rt::as_i64(e)),
                                None => (0i32, 0i64),
                            };
                            (4i32, result3_0, result3_1)
                        }
                    };
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:durability/durability@1.2.0")]
                    extern "C" {
                        #[link_name = "persist-durable-function-invocation"]
                        fn wit_import(
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: i32,
                            _: i32,
                            _: i64,
                        );
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                        _: usize,
                        _: i32,
                        _: i32,
                        _: i64,
                    ) {
                        unreachable!()
                    }
                    wit_import(
                        ptr0.cast_mut(),
                        len0,
                        ptr1.cast_mut(),
                        len1,
                        ptr2.cast_mut(),
                        len2,
                        result5_0,
                        result5_1,
                        result5_2,
                    );
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Writes a record to the worker's oplog representing a durable function invocation
            ///
            /// The request and response are defined as pairs of value and type, which makes it
            /// self-describing for observers of oplogs. This is the recommended way to persist
            /// third-party function invocations.
            pub fn persist_typed_durable_function_invocation(
                function_name: &str,
                request: &ValueAndType,
                response: &ValueAndType,
                function_type: DurableFunctionType,
            ) {
                unsafe {
                    let mut cleanup_list = _rt::Vec::new();
                    let vec0 = function_name;
                    let ptr0 = vec0.as_ptr().cast::<u8>();
                    let len0 = vec0.len();
                    let super::super::super::golem::rpc::types::ValueAndType {
                        value: value1,
                        typ: typ1,
                    } = request;
                    let super::super::super::golem::rpc::types::WitValue {
                        nodes: nodes2,
                    } = value1;
                    let vec13 = nodes2;
                    let len13 = vec13.len();
                    let layout13 = _rt::alloc::Layout::from_size_align_unchecked(
                        vec13.len() * 24,
                        8,
                    );
                    let result13 = if layout13.size() != 0 {
                        let ptr = _rt::alloc::alloc(layout13).cast::<u8>();
                        if ptr.is_null() {
                            _rt::alloc::handle_alloc_error(layout13);
                        }
                        ptr
                    } else {
                        ::core::ptr::null_mut()
                    };
                    for (i, e) in vec13.into_iter().enumerate() {
                        let base = result13.add(i * 24);
                        {
                            use super::super::super::golem::rpc::types::WitNode as V12;
                            match e {
                                V12::RecordValue(e) => {
                                    *base.add(0).cast::<u8>() = (0i32) as u8;
                                    let vec3 = e;
                                    let ptr3 = vec3.as_ptr().cast::<u8>();
                                    let len3 = vec3.len();
                                    *base.add(12).cast::<usize>() = len3;
                                    *base.add(8).cast::<*mut u8>() = ptr3.cast_mut();
                                }
                                V12::VariantValue(e) => {
                                    *base.add(0).cast::<u8>() = (1i32) as u8;
                                    let (t4_0, t4_1) = e;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(t4_0);
                                    match t4_1 {
                                        Some(e) => {
                                            *base.add(12).cast::<u8>() = (1i32) as u8;
                                            *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                        }
                                        None => {
                                            *base.add(12).cast::<u8>() = (0i32) as u8;
                                        }
                                    };
                                }
                                V12::EnumValue(e) => {
                                    *base.add(0).cast::<u8>() = (2i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                V12::FlagsValue(e) => {
                                    *base.add(0).cast::<u8>() = (3i32) as u8;
                                    let vec5 = e;
                                    let len5 = vec5.len();
                                    let layout5 = _rt::alloc::Layout::from_size_align_unchecked(
                                        vec5.len() * 1,
                                        1,
                                    );
                                    let result5 = if layout5.size() != 0 {
                                        let ptr = _rt::alloc::alloc(layout5).cast::<u8>();
                                        if ptr.is_null() {
                                            _rt::alloc::handle_alloc_error(layout5);
                                        }
                                        ptr
                                    } else {
                                        ::core::ptr::null_mut()
                                    };
                                    for (i, e) in vec5.into_iter().enumerate() {
                                        let base = result5.add(i * 1);
                                        {
                                            *base.add(0).cast::<u8>() = (match e {
                                                true => 1,
                                                false => 0,
                                            }) as u8;
                                        }
                                    }
                                    *base.add(12).cast::<usize>() = len5;
                                    *base.add(8).cast::<*mut u8>() = result5;
                                    cleanup_list.extend_from_slice(&[(result5, layout5)]);
                                }
                                V12::TupleValue(e) => {
                                    *base.add(0).cast::<u8>() = (4i32) as u8;
                                    let vec6 = e;
                                    let ptr6 = vec6.as_ptr().cast::<u8>();
                                    let len6 = vec6.len();
                                    *base.add(12).cast::<usize>() = len6;
                                    *base.add(8).cast::<*mut u8>() = ptr6.cast_mut();
                                }
                                V12::ListValue(e) => {
                                    *base.add(0).cast::<u8>() = (5i32) as u8;
                                    let vec7 = e;
                                    let ptr7 = vec7.as_ptr().cast::<u8>();
                                    let len7 = vec7.len();
                                    *base.add(12).cast::<usize>() = len7;
                                    *base.add(8).cast::<*mut u8>() = ptr7.cast_mut();
                                }
                                V12::OptionValue(e) => {
                                    *base.add(0).cast::<u8>() = (6i32) as u8;
                                    match e {
                                        Some(e) => {
                                            *base.add(8).cast::<u8>() = (1i32) as u8;
                                            *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                        }
                                        None => {
                                            *base.add(8).cast::<u8>() = (0i32) as u8;
                                        }
                                    };
                                }
                                V12::ResultValue(e) => {
                                    *base.add(0).cast::<u8>() = (7i32) as u8;
                                    match e {
                                        Ok(e) => {
                                            *base.add(8).cast::<u8>() = (0i32) as u8;
                                            match e {
                                                Some(e) => {
                                                    *base.add(12).cast::<u8>() = (1i32) as u8;
                                                    *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                }
                                                None => {
                                                    *base.add(12).cast::<u8>() = (0i32) as u8;
                                                }
                                            };
                                        }
                                        Err(e) => {
                                            *base.add(8).cast::<u8>() = (1i32) as u8;
                                            match e {
                                                Some(e) => {
                                                    *base.add(12).cast::<u8>() = (1i32) as u8;
                                                    *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                }
                                                None => {
                                                    *base.add(12).cast::<u8>() = (0i32) as u8;
                                                }
                                            };
                                        }
                                    };
                                }
                                V12::PrimU8(e) => {
                                    *base.add(0).cast::<u8>() = (8i32) as u8;
                                    *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                }
                                V12::PrimU16(e) => {
                                    *base.add(0).cast::<u8>() = (9i32) as u8;
                                    *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                }
                                V12::PrimU32(e) => {
                                    *base.add(0).cast::<u8>() = (10i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                V12::PrimU64(e) => {
                                    *base.add(0).cast::<u8>() = (11i32) as u8;
                                    *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                }
                                V12::PrimS8(e) => {
                                    *base.add(0).cast::<u8>() = (12i32) as u8;
                                    *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                }
                                V12::PrimS16(e) => {
                                    *base.add(0).cast::<u8>() = (13i32) as u8;
                                    *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                }
                                V12::PrimS32(e) => {
                                    *base.add(0).cast::<u8>() = (14i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                V12::PrimS64(e) => {
                                    *base.add(0).cast::<u8>() = (15i32) as u8;
                                    *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                }
                                V12::PrimFloat32(e) => {
                                    *base.add(0).cast::<u8>() = (16i32) as u8;
                                    *base.add(8).cast::<f32>() = _rt::as_f32(e);
                                }
                                V12::PrimFloat64(e) => {
                                    *base.add(0).cast::<u8>() = (17i32) as u8;
                                    *base.add(8).cast::<f64>() = _rt::as_f64(e);
                                }
                                V12::PrimChar(e) => {
                                    *base.add(0).cast::<u8>() = (18i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                V12::PrimBool(e) => {
                                    *base.add(0).cast::<u8>() = (19i32) as u8;
                                    *base.add(8).cast::<u8>() = (match e {
                                        true => 1,
                                        false => 0,
                                    }) as u8;
                                }
                                V12::PrimString(e) => {
                                    *base.add(0).cast::<u8>() = (20i32) as u8;
                                    let vec8 = e;
                                    let ptr8 = vec8.as_ptr().cast::<u8>();
                                    let len8 = vec8.len();
                                    *base.add(12).cast::<usize>() = len8;
                                    *base.add(8).cast::<*mut u8>() = ptr8.cast_mut();
                                }
                                V12::Handle(e) => {
                                    *base.add(0).cast::<u8>() = (21i32) as u8;
                                    let (t9_0, t9_1) = e;
                                    let super::super::super::golem::rpc::types::Uri {
                                        value: value10,
                                    } = t9_0;
                                    let vec11 = value10;
                                    let ptr11 = vec11.as_ptr().cast::<u8>();
                                    let len11 = vec11.len();
                                    *base.add(12).cast::<usize>() = len11;
                                    *base.add(8).cast::<*mut u8>() = ptr11.cast_mut();
                                    *base.add(16).cast::<i64>() = _rt::as_i64(t9_1);
                                }
                            }
                        }
                    }
                    let super::super::super::golem::rpc::types::WitType {
                        nodes: nodes14,
                    } = typ1;
                    let vec29 = nodes14;
                    let len29 = vec29.len();
                    let layout29 = _rt::alloc::Layout::from_size_align_unchecked(
                        vec29.len() * 24,
                        8,
                    );
                    let result29 = if layout29.size() != 0 {
                        let ptr = _rt::alloc::alloc(layout29).cast::<u8>();
                        if ptr.is_null() {
                            _rt::alloc::handle_alloc_error(layout29);
                        }
                        ptr
                    } else {
                        ::core::ptr::null_mut()
                    };
                    for (i, e) in vec29.into_iter().enumerate() {
                        let base = result29.add(i * 24);
                        {
                            use super::super::super::golem::rpc::types::WitTypeNode as V28;
                            match e {
                                V28::RecordType(e) => {
                                    *base.add(0).cast::<u8>() = (0i32) as u8;
                                    let vec17 = e;
                                    let len17 = vec17.len();
                                    let layout17 = _rt::alloc::Layout::from_size_align_unchecked(
                                        vec17.len() * 12,
                                        4,
                                    );
                                    let result17 = if layout17.size() != 0 {
                                        let ptr = _rt::alloc::alloc(layout17).cast::<u8>();
                                        if ptr.is_null() {
                                            _rt::alloc::handle_alloc_error(layout17);
                                        }
                                        ptr
                                    } else {
                                        ::core::ptr::null_mut()
                                    };
                                    for (i, e) in vec17.into_iter().enumerate() {
                                        let base = result17.add(i * 12);
                                        {
                                            let (t15_0, t15_1) = e;
                                            let vec16 = t15_0;
                                            let ptr16 = vec16.as_ptr().cast::<u8>();
                                            let len16 = vec16.len();
                                            *base.add(4).cast::<usize>() = len16;
                                            *base.add(0).cast::<*mut u8>() = ptr16.cast_mut();
                                            *base.add(8).cast::<i32>() = _rt::as_i32(t15_1);
                                        }
                                    }
                                    *base.add(12).cast::<usize>() = len17;
                                    *base.add(8).cast::<*mut u8>() = result17;
                                    cleanup_list.extend_from_slice(&[(result17, layout17)]);
                                }
                                V28::VariantType(e) => {
                                    *base.add(0).cast::<u8>() = (1i32) as u8;
                                    let vec20 = e;
                                    let len20 = vec20.len();
                                    let layout20 = _rt::alloc::Layout::from_size_align_unchecked(
                                        vec20.len() * 16,
                                        4,
                                    );
                                    let result20 = if layout20.size() != 0 {
                                        let ptr = _rt::alloc::alloc(layout20).cast::<u8>();
                                        if ptr.is_null() {
                                            _rt::alloc::handle_alloc_error(layout20);
                                        }
                                        ptr
                                    } else {
                                        ::core::ptr::null_mut()
                                    };
                                    for (i, e) in vec20.into_iter().enumerate() {
                                        let base = result20.add(i * 16);
                                        {
                                            let (t18_0, t18_1) = e;
                                            let vec19 = t18_0;
                                            let ptr19 = vec19.as_ptr().cast::<u8>();
                                            let len19 = vec19.len();
                                            *base.add(4).cast::<usize>() = len19;
                                            *base.add(0).cast::<*mut u8>() = ptr19.cast_mut();
                                            match t18_1 {
                                                Some(e) => {
                                                    *base.add(8).cast::<u8>() = (1i32) as u8;
                                                    *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                                }
                                                None => {
                                                    *base.add(8).cast::<u8>() = (0i32) as u8;
                                                }
                                            };
                                        }
                                    }
                                    *base.add(12).cast::<usize>() = len20;
                                    *base.add(8).cast::<*mut u8>() = result20;
                                    cleanup_list.extend_from_slice(&[(result20, layout20)]);
                                }
                                V28::EnumType(e) => {
                                    *base.add(0).cast::<u8>() = (2i32) as u8;
                                    let vec22 = e;
                                    let len22 = vec22.len();
                                    let layout22 = _rt::alloc::Layout::from_size_align_unchecked(
                                        vec22.len() * 8,
                                        4,
                                    );
                                    let result22 = if layout22.size() != 0 {
                                        let ptr = _rt::alloc::alloc(layout22).cast::<u8>();
                                        if ptr.is_null() {
                                            _rt::alloc::handle_alloc_error(layout22);
                                        }
                                        ptr
                                    } else {
                                        ::core::ptr::null_mut()
                                    };
                                    for (i, e) in vec22.into_iter().enumerate() {
                                        let base = result22.add(i * 8);
                                        {
                                            let vec21 = e;
                                            let ptr21 = vec21.as_ptr().cast::<u8>();
                                            let len21 = vec21.len();
                                            *base.add(4).cast::<usize>() = len21;
                                            *base.add(0).cast::<*mut u8>() = ptr21.cast_mut();
                                        }
                                    }
                                    *base.add(12).cast::<usize>() = len22;
                                    *base.add(8).cast::<*mut u8>() = result22;
                                    cleanup_list.extend_from_slice(&[(result22, layout22)]);
                                }
                                V28::FlagsType(e) => {
                                    *base.add(0).cast::<u8>() = (3i32) as u8;
                                    let vec24 = e;
                                    let len24 = vec24.len();
                                    let layout24 = _rt::alloc::Layout::from_size_align_unchecked(
                                        vec24.len() * 8,
                                        4,
                                    );
                                    let result24 = if layout24.size() != 0 {
                                        let ptr = _rt::alloc::alloc(layout24).cast::<u8>();
                                        if ptr.is_null() {
                                            _rt::alloc::handle_alloc_error(layout24);
                                        }
                                        ptr
                                    } else {
                                        ::core::ptr::null_mut()
                                    };
                                    for (i, e) in vec24.into_iter().enumerate() {
                                        let base = result24.add(i * 8);
                                        {
                                            let vec23 = e;
                                            let ptr23 = vec23.as_ptr().cast::<u8>();
                                            let len23 = vec23.len();
                                            *base.add(4).cast::<usize>() = len23;
                                            *base.add(0).cast::<*mut u8>() = ptr23.cast_mut();
                                        }
                                    }
                                    *base.add(12).cast::<usize>() = len24;
                                    *base.add(8).cast::<*mut u8>() = result24;
                                    cleanup_list.extend_from_slice(&[(result24, layout24)]);
                                }
                                V28::TupleType(e) => {
                                    *base.add(0).cast::<u8>() = (4i32) as u8;
                                    let vec25 = e;
                                    let ptr25 = vec25.as_ptr().cast::<u8>();
                                    let len25 = vec25.len();
                                    *base.add(12).cast::<usize>() = len25;
                                    *base.add(8).cast::<*mut u8>() = ptr25.cast_mut();
                                }
                                V28::ListType(e) => {
                                    *base.add(0).cast::<u8>() = (5i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                V28::OptionType(e) => {
                                    *base.add(0).cast::<u8>() = (6i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                V28::ResultType(e) => {
                                    *base.add(0).cast::<u8>() = (7i32) as u8;
                                    let (t26_0, t26_1) = e;
                                    match t26_0 {
                                        Some(e) => {
                                            *base.add(8).cast::<u8>() = (1i32) as u8;
                                            *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                        }
                                        None => {
                                            *base.add(8).cast::<u8>() = (0i32) as u8;
                                        }
                                    };
                                    match t26_1 {
                                        Some(e) => {
                                            *base.add(16).cast::<u8>() = (1i32) as u8;
                                            *base.add(20).cast::<i32>() = _rt::as_i32(e);
                                        }
                                        None => {
                                            *base.add(16).cast::<u8>() = (0i32) as u8;
                                        }
                                    };
                                }
                                V28::PrimU8Type => {
                                    *base.add(0).cast::<u8>() = (8i32) as u8;
                                }
                                V28::PrimU16Type => {
                                    *base.add(0).cast::<u8>() = (9i32) as u8;
                                }
                                V28::PrimU32Type => {
                                    *base.add(0).cast::<u8>() = (10i32) as u8;
                                }
                                V28::PrimU64Type => {
                                    *base.add(0).cast::<u8>() = (11i32) as u8;
                                }
                                V28::PrimS8Type => {
                                    *base.add(0).cast::<u8>() = (12i32) as u8;
                                }
                                V28::PrimS16Type => {
                                    *base.add(0).cast::<u8>() = (13i32) as u8;
                                }
                                V28::PrimS32Type => {
                                    *base.add(0).cast::<u8>() = (14i32) as u8;
                                }
                                V28::PrimS64Type => {
                                    *base.add(0).cast::<u8>() = (15i32) as u8;
                                }
                                V28::PrimF32Type => {
                                    *base.add(0).cast::<u8>() = (16i32) as u8;
                                }
                                V28::PrimF64Type => {
                                    *base.add(0).cast::<u8>() = (17i32) as u8;
                                }
                                V28::PrimCharType => {
                                    *base.add(0).cast::<u8>() = (18i32) as u8;
                                }
                                V28::PrimBoolType => {
                                    *base.add(0).cast::<u8>() = (19i32) as u8;
                                }
                                V28::PrimStringType => {
                                    *base.add(0).cast::<u8>() = (20i32) as u8;
                                }
                                V28::HandleType(e) => {
                                    *base.add(0).cast::<u8>() = (21i32) as u8;
                                    let (t27_0, t27_1) = e;
                                    *base.add(8).cast::<i64>() = _rt::as_i64(t27_0);
                                    *base.add(16).cast::<u8>() = (t27_1.clone() as i32) as u8;
                                }
                            }
                        }
                    }
                    let super::super::super::golem::rpc::types::ValueAndType {
                        value: value30,
                        typ: typ30,
                    } = response;
                    let super::super::super::golem::rpc::types::WitValue {
                        nodes: nodes31,
                    } = value30;
                    let vec42 = nodes31;
                    let len42 = vec42.len();
                    let layout42 = _rt::alloc::Layout::from_size_align_unchecked(
                        vec42.len() * 24,
                        8,
                    );
                    let result42 = if layout42.size() != 0 {
                        let ptr = _rt::alloc::alloc(layout42).cast::<u8>();
                        if ptr.is_null() {
                            _rt::alloc::handle_alloc_error(layout42);
                        }
                        ptr
                    } else {
                        ::core::ptr::null_mut()
                    };
                    for (i, e) in vec42.into_iter().enumerate() {
                        let base = result42.add(i * 24);
                        {
                            use super::super::super::golem::rpc::types::WitNode as V41;
                            match e {
                                V41::RecordValue(e) => {
                                    *base.add(0).cast::<u8>() = (0i32) as u8;
                                    let vec32 = e;
                                    let ptr32 = vec32.as_ptr().cast::<u8>();
                                    let len32 = vec32.len();
                                    *base.add(12).cast::<usize>() = len32;
                                    *base.add(8).cast::<*mut u8>() = ptr32.cast_mut();
                                }
                                V41::VariantValue(e) => {
                                    *base.add(0).cast::<u8>() = (1i32) as u8;
                                    let (t33_0, t33_1) = e;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(t33_0);
                                    match t33_1 {
                                        Some(e) => {
                                            *base.add(12).cast::<u8>() = (1i32) as u8;
                                            *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                        }
                                        None => {
                                            *base.add(12).cast::<u8>() = (0i32) as u8;
                                        }
                                    };
                                }
                                V41::EnumValue(e) => {
                                    *base.add(0).cast::<u8>() = (2i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                V41::FlagsValue(e) => {
                                    *base.add(0).cast::<u8>() = (3i32) as u8;
                                    let vec34 = e;
                                    let len34 = vec34.len();
                                    let layout34 = _rt::alloc::Layout::from_size_align_unchecked(
                                        vec34.len() * 1,
                                        1,
                                    );
                                    let result34 = if layout34.size() != 0 {
                                        let ptr = _rt::alloc::alloc(layout34).cast::<u8>();
                                        if ptr.is_null() {
                                            _rt::alloc::handle_alloc_error(layout34);
                                        }
                                        ptr
                                    } else {
                                        ::core::ptr::null_mut()
                                    };
                                    for (i, e) in vec34.into_iter().enumerate() {
                                        let base = result34.add(i * 1);
                                        {
                                            *base.add(0).cast::<u8>() = (match e {
                                                true => 1,
                                                false => 0,
                                            }) as u8;
                                        }
                                    }
                                    *base.add(12).cast::<usize>() = len34;
                                    *base.add(8).cast::<*mut u8>() = result34;
                                    cleanup_list.extend_from_slice(&[(result34, layout34)]);
                                }
                                V41::TupleValue(e) => {
                                    *base.add(0).cast::<u8>() = (4i32) as u8;
                                    let vec35 = e;
                                    let ptr35 = vec35.as_ptr().cast::<u8>();
                                    let len35 = vec35.len();
                                    *base.add(12).cast::<usize>() = len35;
                                    *base.add(8).cast::<*mut u8>() = ptr35.cast_mut();
                                }
                                V41::ListValue(e) => {
                                    *base.add(0).cast::<u8>() = (5i32) as u8;
                                    let vec36 = e;
                                    let ptr36 = vec36.as_ptr().cast::<u8>();
                                    let len36 = vec36.len();
                                    *base.add(12).cast::<usize>() = len36;
                                    *base.add(8).cast::<*mut u8>() = ptr36.cast_mut();
                                }
                                V41::OptionValue(e) => {
                                    *base.add(0).cast::<u8>() = (6i32) as u8;
                                    match e {
                                        Some(e) => {
                                            *base.add(8).cast::<u8>() = (1i32) as u8;
                                            *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                        }
                                        None => {
                                            *base.add(8).cast::<u8>() = (0i32) as u8;
                                        }
                                    };
                                }
                                V41::ResultValue(e) => {
                                    *base.add(0).cast::<u8>() = (7i32) as u8;
                                    match e {
                                        Ok(e) => {
                                            *base.add(8).cast::<u8>() = (0i32) as u8;
                                            match e {
                                                Some(e) => {
                                                    *base.add(12).cast::<u8>() = (1i32) as u8;
                                                    *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                }
                                                None => {
                                                    *base.add(12).cast::<u8>() = (0i32) as u8;
                                                }
                                            };
                                        }
                                        Err(e) => {
                                            *base.add(8).cast::<u8>() = (1i32) as u8;
                                            match e {
                                                Some(e) => {
                                                    *base.add(12).cast::<u8>() = (1i32) as u8;
                                                    *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                }
                                                None => {
                                                    *base.add(12).cast::<u8>() = (0i32) as u8;
                                                }
                                            };
                                        }
                                    };
                                }
                                V41::PrimU8(e) => {
                                    *base.add(0).cast::<u8>() = (8i32) as u8;
                                    *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                }
                                V41::PrimU16(e) => {
                                    *base.add(0).cast::<u8>() = (9i32) as u8;
                                    *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                }
                                V41::PrimU32(e) => {
                                    *base.add(0).cast::<u8>() = (10i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                V41::PrimU64(e) => {
                                    *base.add(0).cast::<u8>() = (11i32) as u8;
                                    *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                }
                                V41::PrimS8(e) => {
                                    *base.add(0).cast::<u8>() = (12i32) as u8;
                                    *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                }
                                V41::PrimS16(e) => {
                                    *base.add(0).cast::<u8>() = (13i32) as u8;
                                    *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                }
                                V41::PrimS32(e) => {
                                    *base.add(0).cast::<u8>() = (14i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                V41::PrimS64(e) => {
                                    *base.add(0).cast::<u8>() = (15i32) as u8;
                                    *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                }
                                V41::PrimFloat32(e) => {
                                    *base.add(0).cast::<u8>() = (16i32) as u8;
                                    *base.add(8).cast::<f32>() = _rt::as_f32(e);
                                }
                                V41::PrimFloat64(e) => {
                                    *base.add(0).cast::<u8>() = (17i32) as u8;
                                    *base.add(8).cast::<f64>() = _rt::as_f64(e);
                                }
                                V41::PrimChar(e) => {
                                    *base.add(0).cast::<u8>() = (18i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                V41::PrimBool(e) => {
                                    *base.add(0).cast::<u8>() = (19i32) as u8;
                                    *base.add(8).cast::<u8>() = (match e {
                                        true => 1,
                                        false => 0,
                                    }) as u8;
                                }
                                V41::PrimString(e) => {
                                    *base.add(0).cast::<u8>() = (20i32) as u8;
                                    let vec37 = e;
                                    let ptr37 = vec37.as_ptr().cast::<u8>();
                                    let len37 = vec37.len();
                                    *base.add(12).cast::<usize>() = len37;
                                    *base.add(8).cast::<*mut u8>() = ptr37.cast_mut();
                                }
                                V41::Handle(e) => {
                                    *base.add(0).cast::<u8>() = (21i32) as u8;
                                    let (t38_0, t38_1) = e;
                                    let super::super::super::golem::rpc::types::Uri {
                                        value: value39,
                                    } = t38_0;
                                    let vec40 = value39;
                                    let ptr40 = vec40.as_ptr().cast::<u8>();
                                    let len40 = vec40.len();
                                    *base.add(12).cast::<usize>() = len40;
                                    *base.add(8).cast::<*mut u8>() = ptr40.cast_mut();
                                    *base.add(16).cast::<i64>() = _rt::as_i64(t38_1);
                                }
                            }
                        }
                    }
                    let super::super::super::golem::rpc::types::WitType {
                        nodes: nodes43,
                    } = typ30;
                    let vec58 = nodes43;
                    let len58 = vec58.len();
                    let layout58 = _rt::alloc::Layout::from_size_align_unchecked(
                        vec58.len() * 24,
                        8,
                    );
                    let result58 = if layout58.size() != 0 {
                        let ptr = _rt::alloc::alloc(layout58).cast::<u8>();
                        if ptr.is_null() {
                            _rt::alloc::handle_alloc_error(layout58);
                        }
                        ptr
                    } else {
                        ::core::ptr::null_mut()
                    };
                    for (i, e) in vec58.into_iter().enumerate() {
                        let base = result58.add(i * 24);
                        {
                            use super::super::super::golem::rpc::types::WitTypeNode as V57;
                            match e {
                                V57::RecordType(e) => {
                                    *base.add(0).cast::<u8>() = (0i32) as u8;
                                    let vec46 = e;
                                    let len46 = vec46.len();
                                    let layout46 = _rt::alloc::Layout::from_size_align_unchecked(
                                        vec46.len() * 12,
                                        4,
                                    );
                                    let result46 = if layout46.size() != 0 {
                                        let ptr = _rt::alloc::alloc(layout46).cast::<u8>();
                                        if ptr.is_null() {
                                            _rt::alloc::handle_alloc_error(layout46);
                                        }
                                        ptr
                                    } else {
                                        ::core::ptr::null_mut()
                                    };
                                    for (i, e) in vec46.into_iter().enumerate() {
                                        let base = result46.add(i * 12);
                                        {
                                            let (t44_0, t44_1) = e;
                                            let vec45 = t44_0;
                                            let ptr45 = vec45.as_ptr().cast::<u8>();
                                            let len45 = vec45.len();
                                            *base.add(4).cast::<usize>() = len45;
                                            *base.add(0).cast::<*mut u8>() = ptr45.cast_mut();
                                            *base.add(8).cast::<i32>() = _rt::as_i32(t44_1);
                                        }
                                    }
                                    *base.add(12).cast::<usize>() = len46;
                                    *base.add(8).cast::<*mut u8>() = result46;
                                    cleanup_list.extend_from_slice(&[(result46, layout46)]);
                                }
                                V57::VariantType(e) => {
                                    *base.add(0).cast::<u8>() = (1i32) as u8;
                                    let vec49 = e;
                                    let len49 = vec49.len();
                                    let layout49 = _rt::alloc::Layout::from_size_align_unchecked(
                                        vec49.len() * 16,
                                        4,
                                    );
                                    let result49 = if layout49.size() != 0 {
                                        let ptr = _rt::alloc::alloc(layout49).cast::<u8>();
                                        if ptr.is_null() {
                                            _rt::alloc::handle_alloc_error(layout49);
                                        }
                                        ptr
                                    } else {
                                        ::core::ptr::null_mut()
                                    };
                                    for (i, e) in vec49.into_iter().enumerate() {
                                        let base = result49.add(i * 16);
                                        {
                                            let (t47_0, t47_1) = e;
                                            let vec48 = t47_0;
                                            let ptr48 = vec48.as_ptr().cast::<u8>();
                                            let len48 = vec48.len();
                                            *base.add(4).cast::<usize>() = len48;
                                            *base.add(0).cast::<*mut u8>() = ptr48.cast_mut();
                                            match t47_1 {
                                                Some(e) => {
                                                    *base.add(8).cast::<u8>() = (1i32) as u8;
                                                    *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                                }
                                                None => {
                                                    *base.add(8).cast::<u8>() = (0i32) as u8;
                                                }
                                            };
                                        }
                                    }
                                    *base.add(12).cast::<usize>() = len49;
                                    *base.add(8).cast::<*mut u8>() = result49;
                                    cleanup_list.extend_from_slice(&[(result49, layout49)]);
                                }
                                V57::EnumType(e) => {
                                    *base.add(0).cast::<u8>() = (2i32) as u8;
                                    let vec51 = e;
                                    let len51 = vec51.len();
                                    let layout51 = _rt::alloc::Layout::from_size_align_unchecked(
                                        vec51.len() * 8,
                                        4,
                                    );
                                    let result51 = if layout51.size() != 0 {
                                        let ptr = _rt::alloc::alloc(layout51).cast::<u8>();
                                        if ptr.is_null() {
                                            _rt::alloc::handle_alloc_error(layout51);
                                        }
                                        ptr
                                    } else {
                                        ::core::ptr::null_mut()
                                    };
                                    for (i, e) in vec51.into_iter().enumerate() {
                                        let base = result51.add(i * 8);
                                        {
                                            let vec50 = e;
                                            let ptr50 = vec50.as_ptr().cast::<u8>();
                                            let len50 = vec50.len();
                                            *base.add(4).cast::<usize>() = len50;
                                            *base.add(0).cast::<*mut u8>() = ptr50.cast_mut();
                                        }
                                    }
                                    *base.add(12).cast::<usize>() = len51;
                                    *base.add(8).cast::<*mut u8>() = result51;
                                    cleanup_list.extend_from_slice(&[(result51, layout51)]);
                                }
                                V57::FlagsType(e) => {
                                    *base.add(0).cast::<u8>() = (3i32) as u8;
                                    let vec53 = e;
                                    let len53 = vec53.len();
                                    let layout53 = _rt::alloc::Layout::from_size_align_unchecked(
                                        vec53.len() * 8,
                                        4,
                                    );
                                    let result53 = if layout53.size() != 0 {
                                        let ptr = _rt::alloc::alloc(layout53).cast::<u8>();
                                        if ptr.is_null() {
                                            _rt::alloc::handle_alloc_error(layout53);
                                        }
                                        ptr
                                    } else {
                                        ::core::ptr::null_mut()
                                    };
                                    for (i, e) in vec53.into_iter().enumerate() {
                                        let base = result53.add(i * 8);
                                        {
                                            let vec52 = e;
                                            let ptr52 = vec52.as_ptr().cast::<u8>();
                                            let len52 = vec52.len();
                                            *base.add(4).cast::<usize>() = len52;
                                            *base.add(0).cast::<*mut u8>() = ptr52.cast_mut();
                                        }
                                    }
                                    *base.add(12).cast::<usize>() = len53;
                                    *base.add(8).cast::<*mut u8>() = result53;
                                    cleanup_list.extend_from_slice(&[(result53, layout53)]);
                                }
                                V57::TupleType(e) => {
                                    *base.add(0).cast::<u8>() = (4i32) as u8;
                                    let vec54 = e;
                                    let ptr54 = vec54.as_ptr().cast::<u8>();
                                    let len54 = vec54.len();
                                    *base.add(12).cast::<usize>() = len54;
                                    *base.add(8).cast::<*mut u8>() = ptr54.cast_mut();
                                }
                                V57::ListType(e) => {
                                    *base.add(0).cast::<u8>() = (5i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                V57::OptionType(e) => {
                                    *base.add(0).cast::<u8>() = (6i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                V57::ResultType(e) => {
                                    *base.add(0).cast::<u8>() = (7i32) as u8;
                                    let (t55_0, t55_1) = e;
                                    match t55_0 {
                                        Some(e) => {
                                            *base.add(8).cast::<u8>() = (1i32) as u8;
                                            *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                        }
                                        None => {
                                            *base.add(8).cast::<u8>() = (0i32) as u8;
                                        }
                                    };
                                    match t55_1 {
                                        Some(e) => {
                                            *base.add(16).cast::<u8>() = (1i32) as u8;
                                            *base.add(20).cast::<i32>() = _rt::as_i32(e);
                                        }
                                        None => {
                                            *base.add(16).cast::<u8>() = (0i32) as u8;
                                        }
                                    };
                                }
                                V57::PrimU8Type => {
                                    *base.add(0).cast::<u8>() = (8i32) as u8;
                                }
                                V57::PrimU16Type => {
                                    *base.add(0).cast::<u8>() = (9i32) as u8;
                                }
                                V57::PrimU32Type => {
                                    *base.add(0).cast::<u8>() = (10i32) as u8;
                                }
                                V57::PrimU64Type => {
                                    *base.add(0).cast::<u8>() = (11i32) as u8;
                                }
                                V57::PrimS8Type => {
                                    *base.add(0).cast::<u8>() = (12i32) as u8;
                                }
                                V57::PrimS16Type => {
                                    *base.add(0).cast::<u8>() = (13i32) as u8;
                                }
                                V57::PrimS32Type => {
                                    *base.add(0).cast::<u8>() = (14i32) as u8;
                                }
                                V57::PrimS64Type => {
                                    *base.add(0).cast::<u8>() = (15i32) as u8;
                                }
                                V57::PrimF32Type => {
                                    *base.add(0).cast::<u8>() = (16i32) as u8;
                                }
                                V57::PrimF64Type => {
                                    *base.add(0).cast::<u8>() = (17i32) as u8;
                                }
                                V57::PrimCharType => {
                                    *base.add(0).cast::<u8>() = (18i32) as u8;
                                }
                                V57::PrimBoolType => {
                                    *base.add(0).cast::<u8>() = (19i32) as u8;
                                }
                                V57::PrimStringType => {
                                    *base.add(0).cast::<u8>() = (20i32) as u8;
                                }
                                V57::HandleType(e) => {
                                    *base.add(0).cast::<u8>() = (21i32) as u8;
                                    let (t56_0, t56_1) = e;
                                    *base.add(8).cast::<i64>() = _rt::as_i64(t56_0);
                                    *base.add(16).cast::<u8>() = (t56_1.clone() as i32) as u8;
                                }
                            }
                        }
                    }
                    use super::super::super::golem::api::oplog::WrappedFunctionType as V60;
                    let (result61_0, result61_1, result61_2) = match function_type {
                        V60::ReadLocal => (0i32, 0i32, 0i64),
                        V60::WriteLocal => (1i32, 0i32, 0i64),
                        V60::ReadRemote => (2i32, 0i32, 0i64),
                        V60::WriteRemote => (3i32, 0i32, 0i64),
                        V60::WriteRemoteBatched(e) => {
                            let (result59_0, result59_1) = match e {
                                Some(e) => (1i32, _rt::as_i64(e)),
                                None => (0i32, 0i64),
                            };
                            (4i32, result59_0, result59_1)
                        }
                    };
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:durability/durability@1.2.0")]
                    extern "C" {
                        #[link_name = "persist-typed-durable-function-invocation"]
                        fn wit_import(
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: i32,
                            _: i32,
                            _: i64,
                        );
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                        _: usize,
                        _: i32,
                        _: i32,
                        _: i64,
                    ) {
                        unreachable!()
                    }
                    wit_import(
                        ptr0.cast_mut(),
                        len0,
                        result13,
                        len13,
                        result29,
                        len29,
                        result42,
                        len42,
                        result58,
                        len58,
                        result61_0,
                        result61_1,
                        result61_2,
                    );
                    if layout13.size() != 0 {
                        _rt::alloc::dealloc(result13.cast(), layout13);
                    }
                    if layout29.size() != 0 {
                        _rt::alloc::dealloc(result29.cast(), layout29);
                    }
                    if layout42.size() != 0 {
                        _rt::alloc::dealloc(result42.cast(), layout42);
                    }
                    if layout58.size() != 0 {
                        _rt::alloc::dealloc(result58.cast(), layout58);
                    }
                    for (ptr, layout) in cleanup_list {
                        if layout.size() != 0 {
                            _rt::alloc::dealloc(ptr.cast(), layout);
                        }
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Reads the next persisted durable function invocation from the oplog during replay
            pub fn read_persisted_durable_function_invocation() -> PersistedDurableFunctionInvocation {
                unsafe {
                    #[repr(align(8))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 64]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 64]);
                    let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:durability/durability@1.2.0")]
                    extern "C" {
                        #[link_name = "read-persisted-durable-function-invocation"]
                        fn wit_import(_: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: *mut u8) {
                        unreachable!()
                    }
                    wit_import(ptr0);
                    let l1 = *ptr0.add(0).cast::<i64>();
                    let l2 = *ptr0.add(8).cast::<i32>();
                    let l3 = *ptr0.add(16).cast::<*mut u8>();
                    let l4 = *ptr0.add(20).cast::<usize>();
                    let len5 = l4;
                    let bytes5 = _rt::Vec::from_raw_parts(l3.cast(), len5, len5);
                    let l6 = *ptr0.add(24).cast::<*mut u8>();
                    let l7 = *ptr0.add(28).cast::<usize>();
                    let len8 = l7;
                    let l9 = i32::from(*ptr0.add(32).cast::<u8>());
                    use super::super::super::golem::api::oplog::WrappedFunctionType as V12;
                    let v12 = match l9 {
                        0 => V12::ReadLocal,
                        1 => V12::WriteLocal,
                        2 => V12::ReadRemote,
                        3 => V12::WriteRemote,
                        n => {
                            debug_assert_eq!(n, 4, "invalid enum discriminant");
                            let e12 = {
                                let l10 = i32::from(*ptr0.add(40).cast::<u8>());
                                match l10 {
                                    0 => None,
                                    1 => {
                                        let e = {
                                            let l11 = *ptr0.add(48).cast::<i64>();
                                            l11 as u64
                                        };
                                        Some(e)
                                    }
                                    _ => _rt::invalid_enum_discriminant(),
                                }
                            };
                            V12::WriteRemoteBatched(e12)
                        }
                    };
                    let l13 = i32::from(*ptr0.add(56).cast::<u8>());
                    PersistedDurableFunctionInvocation {
                        timestamp: super::super::super::wasi::clocks::wall_clock::Datetime {
                            seconds: l1 as u64,
                            nanoseconds: l2 as u32,
                        },
                        function_name: _rt::string_lift(bytes5),
                        response: _rt::Vec::from_raw_parts(l6.cast(), len8, len8),
                        function_type: v12,
                        entry_version: OplogEntryVersion::_lift(l13 as u8),
                    }
                }
            }
        }
    }
    pub mod rdbms {
        #[allow(dead_code, clippy::all)]
        pub mod types {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct Uuid {
                pub high_bits: u64,
                pub low_bits: u64,
            }
            impl ::core::fmt::Debug for Uuid {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Uuid")
                        .field("high-bits", &self.high_bits)
                        .field("low-bits", &self.low_bits)
                        .finish()
                }
            }
            #[derive(Clone, Copy)]
            pub enum IpAddress {
                Ipv4((u8, u8, u8, u8)),
                Ipv6((u16, u16, u16, u16, u16, u16, u16, u16)),
            }
            impl ::core::fmt::Debug for IpAddress {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        IpAddress::Ipv4(e) => {
                            f.debug_tuple("IpAddress::Ipv4").field(e).finish()
                        }
                        IpAddress::Ipv6(e) => {
                            f.debug_tuple("IpAddress::Ipv6").field(e).finish()
                        }
                    }
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct MacAddress {
                pub octets: (u8, u8, u8, u8, u8, u8),
            }
            impl ::core::fmt::Debug for MacAddress {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("MacAddress").field("octets", &self.octets).finish()
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct Date {
                pub year: i32,
                pub month: u8,
                pub day: u8,
            }
            impl ::core::fmt::Debug for Date {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Date")
                        .field("year", &self.year)
                        .field("month", &self.month)
                        .field("day", &self.day)
                        .finish()
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct Time {
                pub hour: u8,
                pub minute: u8,
                pub second: u8,
                pub nanosecond: u32,
            }
            impl ::core::fmt::Debug for Time {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Time")
                        .field("hour", &self.hour)
                        .field("minute", &self.minute)
                        .field("second", &self.second)
                        .field("nanosecond", &self.nanosecond)
                        .finish()
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct Timestamp {
                pub date: Date,
                pub time: Time,
            }
            impl ::core::fmt::Debug for Timestamp {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Timestamp")
                        .field("date", &self.date)
                        .field("time", &self.time)
                        .finish()
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct Timestamptz {
                pub timestamp: Timestamp,
                pub offset: i32,
            }
            impl ::core::fmt::Debug for Timestamptz {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Timestamptz")
                        .field("timestamp", &self.timestamp)
                        .field("offset", &self.offset)
                        .finish()
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct Timetz {
                pub time: Time,
                pub offset: i32,
            }
            impl ::core::fmt::Debug for Timetz {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Timetz")
                        .field("time", &self.time)
                        .field("offset", &self.offset)
                        .finish()
                }
            }
        }
        #[allow(dead_code, clippy::all)]
        pub mod mysql {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            use super::super::super::_rt;
            pub type Date = super::super::super::golem::rdbms::types::Date;
            pub type Time = super::super::super::golem::rdbms::types::Time;
            pub type Timestamp = super::super::super::golem::rdbms::types::Timestamp;
            #[derive(Clone)]
            pub enum Error {
                ConnectionFailure(_rt::String),
                QueryParameterFailure(_rt::String),
                QueryExecutionFailure(_rt::String),
                QueryResponseFailure(_rt::String),
                Other(_rt::String),
            }
            impl ::core::fmt::Debug for Error {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        Error::ConnectionFailure(e) => {
                            f.debug_tuple("Error::ConnectionFailure").field(e).finish()
                        }
                        Error::QueryParameterFailure(e) => {
                            f.debug_tuple("Error::QueryParameterFailure")
                                .field(e)
                                .finish()
                        }
                        Error::QueryExecutionFailure(e) => {
                            f.debug_tuple("Error::QueryExecutionFailure")
                                .field(e)
                                .finish()
                        }
                        Error::QueryResponseFailure(e) => {
                            f.debug_tuple("Error::QueryResponseFailure")
                                .field(e)
                                .finish()
                        }
                        Error::Other(e) => {
                            f.debug_tuple("Error::Other").field(e).finish()
                        }
                    }
                }
            }
            impl ::core::fmt::Display for Error {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    write!(f, "{:?}", self)
                }
            }
            impl std::error::Error for Error {}
            #[derive(Clone, Copy)]
            pub enum DbColumnType {
                Boolean,
                Tinyint,
                Smallint,
                Mediumint,
                Int,
                Bigint,
                TinyintUnsigned,
                SmallintUnsigned,
                MediumintUnsigned,
                IntUnsigned,
                BigintUnsigned,
                Float,
                Double,
                Decimal,
                Date,
                Datetime,
                Timestamp,
                Time,
                Year,
                Fixchar,
                Varchar,
                Tinytext,
                Text,
                Mediumtext,
                Longtext,
                Binary,
                Varbinary,
                Tinyblob,
                Blob,
                Mediumblob,
                Longblob,
                Enumeration,
                Set,
                Bit,
                Json,
            }
            impl ::core::fmt::Debug for DbColumnType {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        DbColumnType::Boolean => {
                            f.debug_tuple("DbColumnType::Boolean").finish()
                        }
                        DbColumnType::Tinyint => {
                            f.debug_tuple("DbColumnType::Tinyint").finish()
                        }
                        DbColumnType::Smallint => {
                            f.debug_tuple("DbColumnType::Smallint").finish()
                        }
                        DbColumnType::Mediumint => {
                            f.debug_tuple("DbColumnType::Mediumint").finish()
                        }
                        DbColumnType::Int => f.debug_tuple("DbColumnType::Int").finish(),
                        DbColumnType::Bigint => {
                            f.debug_tuple("DbColumnType::Bigint").finish()
                        }
                        DbColumnType::TinyintUnsigned => {
                            f.debug_tuple("DbColumnType::TinyintUnsigned").finish()
                        }
                        DbColumnType::SmallintUnsigned => {
                            f.debug_tuple("DbColumnType::SmallintUnsigned").finish()
                        }
                        DbColumnType::MediumintUnsigned => {
                            f.debug_tuple("DbColumnType::MediumintUnsigned").finish()
                        }
                        DbColumnType::IntUnsigned => {
                            f.debug_tuple("DbColumnType::IntUnsigned").finish()
                        }
                        DbColumnType::BigintUnsigned => {
                            f.debug_tuple("DbColumnType::BigintUnsigned").finish()
                        }
                        DbColumnType::Float => {
                            f.debug_tuple("DbColumnType::Float").finish()
                        }
                        DbColumnType::Double => {
                            f.debug_tuple("DbColumnType::Double").finish()
                        }
                        DbColumnType::Decimal => {
                            f.debug_tuple("DbColumnType::Decimal").finish()
                        }
                        DbColumnType::Date => {
                            f.debug_tuple("DbColumnType::Date").finish()
                        }
                        DbColumnType::Datetime => {
                            f.debug_tuple("DbColumnType::Datetime").finish()
                        }
                        DbColumnType::Timestamp => {
                            f.debug_tuple("DbColumnType::Timestamp").finish()
                        }
                        DbColumnType::Time => {
                            f.debug_tuple("DbColumnType::Time").finish()
                        }
                        DbColumnType::Year => {
                            f.debug_tuple("DbColumnType::Year").finish()
                        }
                        DbColumnType::Fixchar => {
                            f.debug_tuple("DbColumnType::Fixchar").finish()
                        }
                        DbColumnType::Varchar => {
                            f.debug_tuple("DbColumnType::Varchar").finish()
                        }
                        DbColumnType::Tinytext => {
                            f.debug_tuple("DbColumnType::Tinytext").finish()
                        }
                        DbColumnType::Text => {
                            f.debug_tuple("DbColumnType::Text").finish()
                        }
                        DbColumnType::Mediumtext => {
                            f.debug_tuple("DbColumnType::Mediumtext").finish()
                        }
                        DbColumnType::Longtext => {
                            f.debug_tuple("DbColumnType::Longtext").finish()
                        }
                        DbColumnType::Binary => {
                            f.debug_tuple("DbColumnType::Binary").finish()
                        }
                        DbColumnType::Varbinary => {
                            f.debug_tuple("DbColumnType::Varbinary").finish()
                        }
                        DbColumnType::Tinyblob => {
                            f.debug_tuple("DbColumnType::Tinyblob").finish()
                        }
                        DbColumnType::Blob => {
                            f.debug_tuple("DbColumnType::Blob").finish()
                        }
                        DbColumnType::Mediumblob => {
                            f.debug_tuple("DbColumnType::Mediumblob").finish()
                        }
                        DbColumnType::Longblob => {
                            f.debug_tuple("DbColumnType::Longblob").finish()
                        }
                        DbColumnType::Enumeration => {
                            f.debug_tuple("DbColumnType::Enumeration").finish()
                        }
                        DbColumnType::Set => f.debug_tuple("DbColumnType::Set").finish(),
                        DbColumnType::Bit => f.debug_tuple("DbColumnType::Bit").finish(),
                        DbColumnType::Json => {
                            f.debug_tuple("DbColumnType::Json").finish()
                        }
                    }
                }
            }
            #[derive(Clone)]
            pub struct DbColumn {
                pub ordinal: u64,
                pub name: _rt::String,
                pub db_type: DbColumnType,
                pub db_type_name: _rt::String,
            }
            impl ::core::fmt::Debug for DbColumn {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("DbColumn")
                        .field("ordinal", &self.ordinal)
                        .field("name", &self.name)
                        .field("db-type", &self.db_type)
                        .field("db-type-name", &self.db_type_name)
                        .finish()
                }
            }
            /// Value descriptor for a single database value
            #[derive(Clone)]
            pub enum DbValue {
                Boolean(bool),
                Tinyint(i8),
                Smallint(i16),
                /// s24
                Mediumint(i32),
                Int(i32),
                Bigint(i64),
                TinyintUnsigned(u8),
                SmallintUnsigned(u16),
                /// u24
                MediumintUnsigned(u32),
                IntUnsigned(u32),
                BigintUnsigned(u64),
                Float(f32),
                Double(f64),
                Decimal(_rt::String),
                Date(Date),
                Datetime(Timestamp),
                Timestamp(Timestamp),
                Time(Time),
                Year(u16),
                Fixchar(_rt::String),
                Varchar(_rt::String),
                Tinytext(_rt::String),
                Text(_rt::String),
                Mediumtext(_rt::String),
                Longtext(_rt::String),
                Binary(_rt::Vec<u8>),
                Varbinary(_rt::Vec<u8>),
                Tinyblob(_rt::Vec<u8>),
                Blob(_rt::Vec<u8>),
                Mediumblob(_rt::Vec<u8>),
                Longblob(_rt::Vec<u8>),
                Enumeration(_rt::String),
                Set(_rt::String),
                Bit(_rt::Vec<bool>),
                Json(_rt::String),
                Null,
            }
            impl ::core::fmt::Debug for DbValue {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        DbValue::Boolean(e) => {
                            f.debug_tuple("DbValue::Boolean").field(e).finish()
                        }
                        DbValue::Tinyint(e) => {
                            f.debug_tuple("DbValue::Tinyint").field(e).finish()
                        }
                        DbValue::Smallint(e) => {
                            f.debug_tuple("DbValue::Smallint").field(e).finish()
                        }
                        DbValue::Mediumint(e) => {
                            f.debug_tuple("DbValue::Mediumint").field(e).finish()
                        }
                        DbValue::Int(e) => {
                            f.debug_tuple("DbValue::Int").field(e).finish()
                        }
                        DbValue::Bigint(e) => {
                            f.debug_tuple("DbValue::Bigint").field(e).finish()
                        }
                        DbValue::TinyintUnsigned(e) => {
                            f.debug_tuple("DbValue::TinyintUnsigned").field(e).finish()
                        }
                        DbValue::SmallintUnsigned(e) => {
                            f.debug_tuple("DbValue::SmallintUnsigned").field(e).finish()
                        }
                        DbValue::MediumintUnsigned(e) => {
                            f.debug_tuple("DbValue::MediumintUnsigned").field(e).finish()
                        }
                        DbValue::IntUnsigned(e) => {
                            f.debug_tuple("DbValue::IntUnsigned").field(e).finish()
                        }
                        DbValue::BigintUnsigned(e) => {
                            f.debug_tuple("DbValue::BigintUnsigned").field(e).finish()
                        }
                        DbValue::Float(e) => {
                            f.debug_tuple("DbValue::Float").field(e).finish()
                        }
                        DbValue::Double(e) => {
                            f.debug_tuple("DbValue::Double").field(e).finish()
                        }
                        DbValue::Decimal(e) => {
                            f.debug_tuple("DbValue::Decimal").field(e).finish()
                        }
                        DbValue::Date(e) => {
                            f.debug_tuple("DbValue::Date").field(e).finish()
                        }
                        DbValue::Datetime(e) => {
                            f.debug_tuple("DbValue::Datetime").field(e).finish()
                        }
                        DbValue::Timestamp(e) => {
                            f.debug_tuple("DbValue::Timestamp").field(e).finish()
                        }
                        DbValue::Time(e) => {
                            f.debug_tuple("DbValue::Time").field(e).finish()
                        }
                        DbValue::Year(e) => {
                            f.debug_tuple("DbValue::Year").field(e).finish()
                        }
                        DbValue::Fixchar(e) => {
                            f.debug_tuple("DbValue::Fixchar").field(e).finish()
                        }
                        DbValue::Varchar(e) => {
                            f.debug_tuple("DbValue::Varchar").field(e).finish()
                        }
                        DbValue::Tinytext(e) => {
                            f.debug_tuple("DbValue::Tinytext").field(e).finish()
                        }
                        DbValue::Text(e) => {
                            f.debug_tuple("DbValue::Text").field(e).finish()
                        }
                        DbValue::Mediumtext(e) => {
                            f.debug_tuple("DbValue::Mediumtext").field(e).finish()
                        }
                        DbValue::Longtext(e) => {
                            f.debug_tuple("DbValue::Longtext").field(e).finish()
                        }
                        DbValue::Binary(e) => {
                            f.debug_tuple("DbValue::Binary").field(e).finish()
                        }
                        DbValue::Varbinary(e) => {
                            f.debug_tuple("DbValue::Varbinary").field(e).finish()
                        }
                        DbValue::Tinyblob(e) => {
                            f.debug_tuple("DbValue::Tinyblob").field(e).finish()
                        }
                        DbValue::Blob(e) => {
                            f.debug_tuple("DbValue::Blob").field(e).finish()
                        }
                        DbValue::Mediumblob(e) => {
                            f.debug_tuple("DbValue::Mediumblob").field(e).finish()
                        }
                        DbValue::Longblob(e) => {
                            f.debug_tuple("DbValue::Longblob").field(e).finish()
                        }
                        DbValue::Enumeration(e) => {
                            f.debug_tuple("DbValue::Enumeration").field(e).finish()
                        }
                        DbValue::Set(e) => {
                            f.debug_tuple("DbValue::Set").field(e).finish()
                        }
                        DbValue::Bit(e) => {
                            f.debug_tuple("DbValue::Bit").field(e).finish()
                        }
                        DbValue::Json(e) => {
                            f.debug_tuple("DbValue::Json").field(e).finish()
                        }
                        DbValue::Null => f.debug_tuple("DbValue::Null").finish(),
                    }
                }
            }
            /// A single row of values
            #[derive(Clone)]
            pub struct DbRow {
                pub values: _rt::Vec<DbValue>,
            }
            impl ::core::fmt::Debug for DbRow {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("DbRow").field("values", &self.values).finish()
                }
            }
            #[derive(Clone)]
            pub struct DbResult {
                pub columns: _rt::Vec<DbColumn>,
                pub rows: _rt::Vec<DbRow>,
            }
            impl ::core::fmt::Debug for DbResult {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("DbResult")
                        .field("columns", &self.columns)
                        .field("rows", &self.rows)
                        .finish()
                }
            }
            /// A potentially very large and lazy stream of rows:
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct DbResultStream {
                handle: _rt::Resource<DbResultStream>,
            }
            impl DbResultStream {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 DbResultStream {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "golem:rdbms/mysql@0.0.1")]
                        extern "C" {
                            #[link_name = "[resource-drop]db-result-stream"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct DbConnection {
                handle: _rt::Resource<DbConnection>,
            }
            impl DbConnection {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 DbConnection {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "golem:rdbms/mysql@0.0.1")]
                        extern "C" {
                            #[link_name = "[resource-drop]db-connection"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct DbTransaction {
                handle: _rt::Resource<DbTransaction>,
            }
            impl DbTransaction {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 DbTransaction {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "golem:rdbms/mysql@0.0.1")]
                        extern "C" {
                            #[link_name = "[resource-drop]db-transaction"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            impl DbResultStream {
                #[allow(unused_unsafe, clippy::all)]
                pub fn get_columns(&self) -> _rt::Vec<DbColumn> {
                    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 = "golem:rdbms/mysql@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-result-stream.get-columns"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = *ptr0.add(0).cast::<*mut u8>();
                        let l2 = *ptr0.add(4).cast::<usize>();
                        let base12 = l1;
                        let len12 = l2;
                        let mut result12 = _rt::Vec::with_capacity(len12);
                        for i in 0..len12 {
                            let base = base12.add(i * 32);
                            let e12 = {
                                let l3 = *base.add(0).cast::<i64>();
                                let l4 = *base.add(8).cast::<*mut u8>();
                                let l5 = *base.add(12).cast::<usize>();
                                let len6 = l5;
                                let bytes6 = _rt::Vec::from_raw_parts(
                                    l4.cast(),
                                    len6,
                                    len6,
                                );
                                let l7 = i32::from(*base.add(16).cast::<u8>());
                                let v8 = match l7 {
                                    0 => DbColumnType::Boolean,
                                    1 => DbColumnType::Tinyint,
                                    2 => DbColumnType::Smallint,
                                    3 => DbColumnType::Mediumint,
                                    4 => DbColumnType::Int,
                                    5 => DbColumnType::Bigint,
                                    6 => DbColumnType::TinyintUnsigned,
                                    7 => DbColumnType::SmallintUnsigned,
                                    8 => DbColumnType::MediumintUnsigned,
                                    9 => DbColumnType::IntUnsigned,
                                    10 => DbColumnType::BigintUnsigned,
                                    11 => DbColumnType::Float,
                                    12 => DbColumnType::Double,
                                    13 => DbColumnType::Decimal,
                                    14 => DbColumnType::Date,
                                    15 => DbColumnType::Datetime,
                                    16 => DbColumnType::Timestamp,
                                    17 => DbColumnType::Time,
                                    18 => DbColumnType::Year,
                                    19 => DbColumnType::Fixchar,
                                    20 => DbColumnType::Varchar,
                                    21 => DbColumnType::Tinytext,
                                    22 => DbColumnType::Text,
                                    23 => DbColumnType::Mediumtext,
                                    24 => DbColumnType::Longtext,
                                    25 => DbColumnType::Binary,
                                    26 => DbColumnType::Varbinary,
                                    27 => DbColumnType::Tinyblob,
                                    28 => DbColumnType::Blob,
                                    29 => DbColumnType::Mediumblob,
                                    30 => DbColumnType::Longblob,
                                    31 => DbColumnType::Enumeration,
                                    32 => DbColumnType::Set,
                                    33 => DbColumnType::Bit,
                                    n => {
                                        debug_assert_eq!(n, 34, "invalid enum discriminant");
                                        DbColumnType::Json
                                    }
                                };
                                let l9 = *base.add(20).cast::<*mut u8>();
                                let l10 = *base.add(24).cast::<usize>();
                                let len11 = l10;
                                let bytes11 = _rt::Vec::from_raw_parts(
                                    l9.cast(),
                                    len11,
                                    len11,
                                );
                                DbColumn {
                                    ordinal: l3 as u64,
                                    name: _rt::string_lift(bytes6),
                                    db_type: v8,
                                    db_type_name: _rt::string_lift(bytes11),
                                }
                            };
                            result12.push(e12);
                        }
                        _rt::cabi_dealloc(base12, len12 * 32, 8);
                        result12
                    }
                }
            }
            impl DbResultStream {
                #[allow(unused_unsafe, clippy::all)]
                pub fn get_next(&self) -> Option<_rt::Vec<DbRow>> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rdbms/mysql@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-result-stream.get-next"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<*mut u8>();
                                    let l3 = *ptr0.add(8).cast::<usize>();
                                    let base96 = l2;
                                    let len96 = l3;
                                    let mut result96 = _rt::Vec::with_capacity(len96);
                                    for i in 0..len96 {
                                        let base = base96.add(i * 8);
                                        let e96 = {
                                            let l4 = *base.add(0).cast::<*mut u8>();
                                            let l5 = *base.add(4).cast::<usize>();
                                            let base95 = l4;
                                            let len95 = l5;
                                            let mut result95 = _rt::Vec::with_capacity(len95);
                                            for i in 0..len95 {
                                                let base = base95.add(i * 24);
                                                let e95 = {
                                                    let l6 = i32::from(*base.add(0).cast::<u8>());
                                                    let v94 = match l6 {
                                                        0 => {
                                                            let e94 = {
                                                                let l7 = i32::from(*base.add(8).cast::<u8>());
                                                                _rt::bool_lift(l7 as u8)
                                                            };
                                                            DbValue::Boolean(e94)
                                                        }
                                                        1 => {
                                                            let e94 = {
                                                                let l8 = i32::from(*base.add(8).cast::<i8>());
                                                                l8 as i8
                                                            };
                                                            DbValue::Tinyint(e94)
                                                        }
                                                        2 => {
                                                            let e94 = {
                                                                let l9 = i32::from(*base.add(8).cast::<i16>());
                                                                l9 as i16
                                                            };
                                                            DbValue::Smallint(e94)
                                                        }
                                                        3 => {
                                                            let e94 = {
                                                                let l10 = *base.add(8).cast::<i32>();
                                                                l10
                                                            };
                                                            DbValue::Mediumint(e94)
                                                        }
                                                        4 => {
                                                            let e94 = {
                                                                let l11 = *base.add(8).cast::<i32>();
                                                                l11
                                                            };
                                                            DbValue::Int(e94)
                                                        }
                                                        5 => {
                                                            let e94 = {
                                                                let l12 = *base.add(8).cast::<i64>();
                                                                l12
                                                            };
                                                            DbValue::Bigint(e94)
                                                        }
                                                        6 => {
                                                            let e94 = {
                                                                let l13 = i32::from(*base.add(8).cast::<u8>());
                                                                l13 as u8
                                                            };
                                                            DbValue::TinyintUnsigned(e94)
                                                        }
                                                        7 => {
                                                            let e94 = {
                                                                let l14 = i32::from(*base.add(8).cast::<u16>());
                                                                l14 as u16
                                                            };
                                                            DbValue::SmallintUnsigned(e94)
                                                        }
                                                        8 => {
                                                            let e94 = {
                                                                let l15 = *base.add(8).cast::<i32>();
                                                                l15 as u32
                                                            };
                                                            DbValue::MediumintUnsigned(e94)
                                                        }
                                                        9 => {
                                                            let e94 = {
                                                                let l16 = *base.add(8).cast::<i32>();
                                                                l16 as u32
                                                            };
                                                            DbValue::IntUnsigned(e94)
                                                        }
                                                        10 => {
                                                            let e94 = {
                                                                let l17 = *base.add(8).cast::<i64>();
                                                                l17 as u64
                                                            };
                                                            DbValue::BigintUnsigned(e94)
                                                        }
                                                        11 => {
                                                            let e94 = {
                                                                let l18 = *base.add(8).cast::<f32>();
                                                                l18
                                                            };
                                                            DbValue::Float(e94)
                                                        }
                                                        12 => {
                                                            let e94 = {
                                                                let l19 = *base.add(8).cast::<f64>();
                                                                l19
                                                            };
                                                            DbValue::Double(e94)
                                                        }
                                                        13 => {
                                                            let e94 = {
                                                                let l20 = *base.add(8).cast::<*mut u8>();
                                                                let l21 = *base.add(12).cast::<usize>();
                                                                let len22 = l21;
                                                                let bytes22 = _rt::Vec::from_raw_parts(
                                                                    l20.cast(),
                                                                    len22,
                                                                    len22,
                                                                );
                                                                _rt::string_lift(bytes22)
                                                            };
                                                            DbValue::Decimal(e94)
                                                        }
                                                        14 => {
                                                            let e94 = {
                                                                let l23 = *base.add(8).cast::<i32>();
                                                                let l24 = i32::from(*base.add(12).cast::<u8>());
                                                                let l25 = i32::from(*base.add(13).cast::<u8>());
                                                                super::super::super::golem::rdbms::types::Date {
                                                                    year: l23,
                                                                    month: l24 as u8,
                                                                    day: l25 as u8,
                                                                }
                                                            };
                                                            DbValue::Date(e94)
                                                        }
                                                        15 => {
                                                            let e94 = {
                                                                let l26 = *base.add(8).cast::<i32>();
                                                                let l27 = i32::from(*base.add(12).cast::<u8>());
                                                                let l28 = i32::from(*base.add(13).cast::<u8>());
                                                                let l29 = i32::from(*base.add(16).cast::<u8>());
                                                                let l30 = i32::from(*base.add(17).cast::<u8>());
                                                                let l31 = i32::from(*base.add(18).cast::<u8>());
                                                                let l32 = *base.add(20).cast::<i32>();
                                                                super::super::super::golem::rdbms::types::Timestamp {
                                                                    date: super::super::super::golem::rdbms::types::Date {
                                                                        year: l26,
                                                                        month: l27 as u8,
                                                                        day: l28 as u8,
                                                                    },
                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                        hour: l29 as u8,
                                                                        minute: l30 as u8,
                                                                        second: l31 as u8,
                                                                        nanosecond: l32 as u32,
                                                                    },
                                                                }
                                                            };
                                                            DbValue::Datetime(e94)
                                                        }
                                                        16 => {
                                                            let e94 = {
                                                                let l33 = *base.add(8).cast::<i32>();
                                                                let l34 = i32::from(*base.add(12).cast::<u8>());
                                                                let l35 = i32::from(*base.add(13).cast::<u8>());
                                                                let l36 = i32::from(*base.add(16).cast::<u8>());
                                                                let l37 = i32::from(*base.add(17).cast::<u8>());
                                                                let l38 = i32::from(*base.add(18).cast::<u8>());
                                                                let l39 = *base.add(20).cast::<i32>();
                                                                super::super::super::golem::rdbms::types::Timestamp {
                                                                    date: super::super::super::golem::rdbms::types::Date {
                                                                        year: l33,
                                                                        month: l34 as u8,
                                                                        day: l35 as u8,
                                                                    },
                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                        hour: l36 as u8,
                                                                        minute: l37 as u8,
                                                                        second: l38 as u8,
                                                                        nanosecond: l39 as u32,
                                                                    },
                                                                }
                                                            };
                                                            DbValue::Timestamp(e94)
                                                        }
                                                        17 => {
                                                            let e94 = {
                                                                let l40 = i32::from(*base.add(8).cast::<u8>());
                                                                let l41 = i32::from(*base.add(9).cast::<u8>());
                                                                let l42 = i32::from(*base.add(10).cast::<u8>());
                                                                let l43 = *base.add(12).cast::<i32>();
                                                                super::super::super::golem::rdbms::types::Time {
                                                                    hour: l40 as u8,
                                                                    minute: l41 as u8,
                                                                    second: l42 as u8,
                                                                    nanosecond: l43 as u32,
                                                                }
                                                            };
                                                            DbValue::Time(e94)
                                                        }
                                                        18 => {
                                                            let e94 = {
                                                                let l44 = i32::from(*base.add(8).cast::<u16>());
                                                                l44 as u16
                                                            };
                                                            DbValue::Year(e94)
                                                        }
                                                        19 => {
                                                            let e94 = {
                                                                let l45 = *base.add(8).cast::<*mut u8>();
                                                                let l46 = *base.add(12).cast::<usize>();
                                                                let len47 = l46;
                                                                let bytes47 = _rt::Vec::from_raw_parts(
                                                                    l45.cast(),
                                                                    len47,
                                                                    len47,
                                                                );
                                                                _rt::string_lift(bytes47)
                                                            };
                                                            DbValue::Fixchar(e94)
                                                        }
                                                        20 => {
                                                            let e94 = {
                                                                let l48 = *base.add(8).cast::<*mut u8>();
                                                                let l49 = *base.add(12).cast::<usize>();
                                                                let len50 = l49;
                                                                let bytes50 = _rt::Vec::from_raw_parts(
                                                                    l48.cast(),
                                                                    len50,
                                                                    len50,
                                                                );
                                                                _rt::string_lift(bytes50)
                                                            };
                                                            DbValue::Varchar(e94)
                                                        }
                                                        21 => {
                                                            let e94 = {
                                                                let l51 = *base.add(8).cast::<*mut u8>();
                                                                let l52 = *base.add(12).cast::<usize>();
                                                                let len53 = l52;
                                                                let bytes53 = _rt::Vec::from_raw_parts(
                                                                    l51.cast(),
                                                                    len53,
                                                                    len53,
                                                                );
                                                                _rt::string_lift(bytes53)
                                                            };
                                                            DbValue::Tinytext(e94)
                                                        }
                                                        22 => {
                                                            let e94 = {
                                                                let l54 = *base.add(8).cast::<*mut u8>();
                                                                let l55 = *base.add(12).cast::<usize>();
                                                                let len56 = l55;
                                                                let bytes56 = _rt::Vec::from_raw_parts(
                                                                    l54.cast(),
                                                                    len56,
                                                                    len56,
                                                                );
                                                                _rt::string_lift(bytes56)
                                                            };
                                                            DbValue::Text(e94)
                                                        }
                                                        23 => {
                                                            let e94 = {
                                                                let l57 = *base.add(8).cast::<*mut u8>();
                                                                let l58 = *base.add(12).cast::<usize>();
                                                                let len59 = l58;
                                                                let bytes59 = _rt::Vec::from_raw_parts(
                                                                    l57.cast(),
                                                                    len59,
                                                                    len59,
                                                                );
                                                                _rt::string_lift(bytes59)
                                                            };
                                                            DbValue::Mediumtext(e94)
                                                        }
                                                        24 => {
                                                            let e94 = {
                                                                let l60 = *base.add(8).cast::<*mut u8>();
                                                                let l61 = *base.add(12).cast::<usize>();
                                                                let len62 = l61;
                                                                let bytes62 = _rt::Vec::from_raw_parts(
                                                                    l60.cast(),
                                                                    len62,
                                                                    len62,
                                                                );
                                                                _rt::string_lift(bytes62)
                                                            };
                                                            DbValue::Longtext(e94)
                                                        }
                                                        25 => {
                                                            let e94 = {
                                                                let l63 = *base.add(8).cast::<*mut u8>();
                                                                let l64 = *base.add(12).cast::<usize>();
                                                                let len65 = l64;
                                                                _rt::Vec::from_raw_parts(l63.cast(), len65, len65)
                                                            };
                                                            DbValue::Binary(e94)
                                                        }
                                                        26 => {
                                                            let e94 = {
                                                                let l66 = *base.add(8).cast::<*mut u8>();
                                                                let l67 = *base.add(12).cast::<usize>();
                                                                let len68 = l67;
                                                                _rt::Vec::from_raw_parts(l66.cast(), len68, len68)
                                                            };
                                                            DbValue::Varbinary(e94)
                                                        }
                                                        27 => {
                                                            let e94 = {
                                                                let l69 = *base.add(8).cast::<*mut u8>();
                                                                let l70 = *base.add(12).cast::<usize>();
                                                                let len71 = l70;
                                                                _rt::Vec::from_raw_parts(l69.cast(), len71, len71)
                                                            };
                                                            DbValue::Tinyblob(e94)
                                                        }
                                                        28 => {
                                                            let e94 = {
                                                                let l72 = *base.add(8).cast::<*mut u8>();
                                                                let l73 = *base.add(12).cast::<usize>();
                                                                let len74 = l73;
                                                                _rt::Vec::from_raw_parts(l72.cast(), len74, len74)
                                                            };
                                                            DbValue::Blob(e94)
                                                        }
                                                        29 => {
                                                            let e94 = {
                                                                let l75 = *base.add(8).cast::<*mut u8>();
                                                                let l76 = *base.add(12).cast::<usize>();
                                                                let len77 = l76;
                                                                _rt::Vec::from_raw_parts(l75.cast(), len77, len77)
                                                            };
                                                            DbValue::Mediumblob(e94)
                                                        }
                                                        30 => {
                                                            let e94 = {
                                                                let l78 = *base.add(8).cast::<*mut u8>();
                                                                let l79 = *base.add(12).cast::<usize>();
                                                                let len80 = l79;
                                                                _rt::Vec::from_raw_parts(l78.cast(), len80, len80)
                                                            };
                                                            DbValue::Longblob(e94)
                                                        }
                                                        31 => {
                                                            let e94 = {
                                                                let l81 = *base.add(8).cast::<*mut u8>();
                                                                let l82 = *base.add(12).cast::<usize>();
                                                                let len83 = l82;
                                                                let bytes83 = _rt::Vec::from_raw_parts(
                                                                    l81.cast(),
                                                                    len83,
                                                                    len83,
                                                                );
                                                                _rt::string_lift(bytes83)
                                                            };
                                                            DbValue::Enumeration(e94)
                                                        }
                                                        32 => {
                                                            let e94 = {
                                                                let l84 = *base.add(8).cast::<*mut u8>();
                                                                let l85 = *base.add(12).cast::<usize>();
                                                                let len86 = l85;
                                                                let bytes86 = _rt::Vec::from_raw_parts(
                                                                    l84.cast(),
                                                                    len86,
                                                                    len86,
                                                                );
                                                                _rt::string_lift(bytes86)
                                                            };
                                                            DbValue::Set(e94)
                                                        }
                                                        33 => {
                                                            let e94 = {
                                                                let l87 = *base.add(8).cast::<*mut u8>();
                                                                let l88 = *base.add(12).cast::<usize>();
                                                                let base90 = l87;
                                                                let len90 = l88;
                                                                let mut result90 = _rt::Vec::with_capacity(len90);
                                                                for i in 0..len90 {
                                                                    let base = base90.add(i * 1);
                                                                    let e90 = {
                                                                        let l89 = i32::from(*base.add(0).cast::<u8>());
                                                                        _rt::bool_lift(l89 as u8)
                                                                    };
                                                                    result90.push(e90);
                                                                }
                                                                _rt::cabi_dealloc(base90, len90 * 1, 1);
                                                                result90
                                                            };
                                                            DbValue::Bit(e94)
                                                        }
                                                        34 => {
                                                            let e94 = {
                                                                let l91 = *base.add(8).cast::<*mut u8>();
                                                                let l92 = *base.add(12).cast::<usize>();
                                                                let len93 = l92;
                                                                let bytes93 = _rt::Vec::from_raw_parts(
                                                                    l91.cast(),
                                                                    len93,
                                                                    len93,
                                                                );
                                                                _rt::string_lift(bytes93)
                                                            };
                                                            DbValue::Json(e94)
                                                        }
                                                        n => {
                                                            debug_assert_eq!(n, 35, "invalid enum discriminant");
                                                            DbValue::Null
                                                        }
                                                    };
                                                    v94
                                                };
                                                result95.push(e95);
                                            }
                                            _rt::cabi_dealloc(base95, len95 * 24, 8);
                                            DbRow { values: result95 }
                                        };
                                        result96.push(e96);
                                    }
                                    _rt::cabi_dealloc(base96, len96 * 8, 4);
                                    result96
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl DbConnection {
                #[allow(unused_unsafe, clippy::all)]
                pub fn open(address: &str) -> Result<DbConnection, Error> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 16]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 16],
                        );
                        let vec0 = address;
                        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 = "golem:rdbms/mysql@0.0.1")]
                        extern "C" {
                            #[link_name = "[static]db-connection.open"]
                            fn wit_import(_: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: *mut u8, _: usize, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import(ptr0.cast_mut(), len0, ptr1);
                        let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                        match l2 {
                            0 => {
                                let e = {
                                    let l3 = *ptr1.add(4).cast::<i32>();
                                    DbConnection::from_handle(l3 as u32)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l4 = i32::from(*ptr1.add(4).cast::<u8>());
                                    let v20 = match l4 {
                                        0 => {
                                            let e20 = {
                                                let l5 = *ptr1.add(8).cast::<*mut u8>();
                                                let l6 = *ptr1.add(12).cast::<usize>();
                                                let len7 = l6;
                                                let bytes7 = _rt::Vec::from_raw_parts(
                                                    l5.cast(),
                                                    len7,
                                                    len7,
                                                );
                                                _rt::string_lift(bytes7)
                                            };
                                            Error::ConnectionFailure(e20)
                                        }
                                        1 => {
                                            let e20 = {
                                                let l8 = *ptr1.add(8).cast::<*mut u8>();
                                                let l9 = *ptr1.add(12).cast::<usize>();
                                                let len10 = l9;
                                                let bytes10 = _rt::Vec::from_raw_parts(
                                                    l8.cast(),
                                                    len10,
                                                    len10,
                                                );
                                                _rt::string_lift(bytes10)
                                            };
                                            Error::QueryParameterFailure(e20)
                                        }
                                        2 => {
                                            let e20 = {
                                                let l11 = *ptr1.add(8).cast::<*mut u8>();
                                                let l12 = *ptr1.add(12).cast::<usize>();
                                                let len13 = l12;
                                                let bytes13 = _rt::Vec::from_raw_parts(
                                                    l11.cast(),
                                                    len13,
                                                    len13,
                                                );
                                                _rt::string_lift(bytes13)
                                            };
                                            Error::QueryExecutionFailure(e20)
                                        }
                                        3 => {
                                            let e20 = {
                                                let l14 = *ptr1.add(8).cast::<*mut u8>();
                                                let l15 = *ptr1.add(12).cast::<usize>();
                                                let len16 = l15;
                                                let bytes16 = _rt::Vec::from_raw_parts(
                                                    l14.cast(),
                                                    len16,
                                                    len16,
                                                );
                                                _rt::string_lift(bytes16)
                                            };
                                            Error::QueryResponseFailure(e20)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 4, "invalid enum discriminant");
                                            let e20 = {
                                                let l17 = *ptr1.add(8).cast::<*mut u8>();
                                                let l18 = *ptr1.add(12).cast::<usize>();
                                                let len19 = l18;
                                                let bytes19 = _rt::Vec::from_raw_parts(
                                                    l17.cast(),
                                                    len19,
                                                    len19,
                                                );
                                                _rt::string_lift(bytes19)
                                            };
                                            Error::Other(e20)
                                        }
                                    };
                                    v20
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl DbConnection {
                #[allow(unused_unsafe, clippy::all)]
                pub fn query(
                    &self,
                    statement: &str,
                    params: &[DbValue],
                ) -> Result<DbResult, Error> {
                    unsafe {
                        let mut cleanup_list = _rt::Vec::new();
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 20]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 20],
                        );
                        let vec0 = statement;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let vec26 = params;
                        let len26 = vec26.len();
                        let layout26 = _rt::alloc::Layout::from_size_align_unchecked(
                            vec26.len() * 24,
                            8,
                        );
                        let result26 = if layout26.size() != 0 {
                            let ptr = _rt::alloc::alloc(layout26).cast::<u8>();
                            if ptr.is_null() {
                                _rt::alloc::handle_alloc_error(layout26);
                            }
                            ptr
                        } else {
                            ::core::ptr::null_mut()
                        };
                        for (i, e) in vec26.into_iter().enumerate() {
                            let base = result26.add(i * 24);
                            {
                                match e {
                                    DbValue::Boolean(e) => {
                                        *base.add(0).cast::<u8>() = (0i32) as u8;
                                        *base.add(8).cast::<u8>() = (match e {
                                            true => 1,
                                            false => 0,
                                        }) as u8;
                                    }
                                    DbValue::Tinyint(e) => {
                                        *base.add(0).cast::<u8>() = (1i32) as u8;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                    }
                                    DbValue::Smallint(e) => {
                                        *base.add(0).cast::<u8>() = (2i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::Mediumint(e) => {
                                        *base.add(0).cast::<u8>() = (3i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Int(e) => {
                                        *base.add(0).cast::<u8>() = (4i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Bigint(e) => {
                                        *base.add(0).cast::<u8>() = (5i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::TinyintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (6i32) as u8;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                    }
                                    DbValue::SmallintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (7i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::MediumintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (8i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::IntUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (9i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::BigintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (10i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::Float(e) => {
                                        *base.add(0).cast::<u8>() = (11i32) as u8;
                                        *base.add(8).cast::<f32>() = _rt::as_f32(e);
                                    }
                                    DbValue::Double(e) => {
                                        *base.add(0).cast::<u8>() = (12i32) as u8;
                                        *base.add(8).cast::<f64>() = _rt::as_f64(e);
                                    }
                                    DbValue::Decimal(e) => {
                                        *base.add(0).cast::<u8>() = (13i32) as u8;
                                        let vec1 = e;
                                        let ptr1 = vec1.as_ptr().cast::<u8>();
                                        let len1 = vec1.len();
                                        *base.add(12).cast::<usize>() = len1;
                                        *base.add(8).cast::<*mut u8>() = ptr1.cast_mut();
                                    }
                                    DbValue::Date(e) => {
                                        *base.add(0).cast::<u8>() = (14i32) as u8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year2,
                                            month: month2,
                                            day: day2,
                                        } = e;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year2);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month2)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day2)) as u8;
                                    }
                                    DbValue::Datetime(e) => {
                                        *base.add(0).cast::<u8>() = (15i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date3,
                                            time: time3,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year4,
                                            month: month4,
                                            day: day4,
                                        } = date3;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year4);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month4)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day4)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour5,
                                            minute: minute5,
                                            second: second5,
                                            nanosecond: nanosecond5,
                                        } = time3;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour5)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute5)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second5)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond5);
                                    }
                                    DbValue::Timestamp(e) => {
                                        *base.add(0).cast::<u8>() = (16i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date6,
                                            time: time6,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year7,
                                            month: month7,
                                            day: day7,
                                        } = date6;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year7);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month7)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day7)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour8,
                                            minute: minute8,
                                            second: second8,
                                            nanosecond: nanosecond8,
                                        } = time6;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour8)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute8)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second8)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond8);
                                    }
                                    DbValue::Time(e) => {
                                        *base.add(0).cast::<u8>() = (17i32) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour9,
                                            minute: minute9,
                                            second: second9,
                                            nanosecond: nanosecond9,
                                        } = e;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(hour9)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(minute9)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(second9)) as u8;
                                        *base.add(12).cast::<i32>() = _rt::as_i32(nanosecond9);
                                    }
                                    DbValue::Year(e) => {
                                        *base.add(0).cast::<u8>() = (18i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::Fixchar(e) => {
                                        *base.add(0).cast::<u8>() = (19i32) as u8;
                                        let vec10 = e;
                                        let ptr10 = vec10.as_ptr().cast::<u8>();
                                        let len10 = vec10.len();
                                        *base.add(12).cast::<usize>() = len10;
                                        *base.add(8).cast::<*mut u8>() = ptr10.cast_mut();
                                    }
                                    DbValue::Varchar(e) => {
                                        *base.add(0).cast::<u8>() = (20i32) as u8;
                                        let vec11 = e;
                                        let ptr11 = vec11.as_ptr().cast::<u8>();
                                        let len11 = vec11.len();
                                        *base.add(12).cast::<usize>() = len11;
                                        *base.add(8).cast::<*mut u8>() = ptr11.cast_mut();
                                    }
                                    DbValue::Tinytext(e) => {
                                        *base.add(0).cast::<u8>() = (21i32) as u8;
                                        let vec12 = e;
                                        let ptr12 = vec12.as_ptr().cast::<u8>();
                                        let len12 = vec12.len();
                                        *base.add(12).cast::<usize>() = len12;
                                        *base.add(8).cast::<*mut u8>() = ptr12.cast_mut();
                                    }
                                    DbValue::Text(e) => {
                                        *base.add(0).cast::<u8>() = (22i32) as u8;
                                        let vec13 = e;
                                        let ptr13 = vec13.as_ptr().cast::<u8>();
                                        let len13 = vec13.len();
                                        *base.add(12).cast::<usize>() = len13;
                                        *base.add(8).cast::<*mut u8>() = ptr13.cast_mut();
                                    }
                                    DbValue::Mediumtext(e) => {
                                        *base.add(0).cast::<u8>() = (23i32) as u8;
                                        let vec14 = e;
                                        let ptr14 = vec14.as_ptr().cast::<u8>();
                                        let len14 = vec14.len();
                                        *base.add(12).cast::<usize>() = len14;
                                        *base.add(8).cast::<*mut u8>() = ptr14.cast_mut();
                                    }
                                    DbValue::Longtext(e) => {
                                        *base.add(0).cast::<u8>() = (24i32) as u8;
                                        let vec15 = e;
                                        let ptr15 = vec15.as_ptr().cast::<u8>();
                                        let len15 = vec15.len();
                                        *base.add(12).cast::<usize>() = len15;
                                        *base.add(8).cast::<*mut u8>() = ptr15.cast_mut();
                                    }
                                    DbValue::Binary(e) => {
                                        *base.add(0).cast::<u8>() = (25i32) as u8;
                                        let vec16 = e;
                                        let ptr16 = vec16.as_ptr().cast::<u8>();
                                        let len16 = vec16.len();
                                        *base.add(12).cast::<usize>() = len16;
                                        *base.add(8).cast::<*mut u8>() = ptr16.cast_mut();
                                    }
                                    DbValue::Varbinary(e) => {
                                        *base.add(0).cast::<u8>() = (26i32) as u8;
                                        let vec17 = e;
                                        let ptr17 = vec17.as_ptr().cast::<u8>();
                                        let len17 = vec17.len();
                                        *base.add(12).cast::<usize>() = len17;
                                        *base.add(8).cast::<*mut u8>() = ptr17.cast_mut();
                                    }
                                    DbValue::Tinyblob(e) => {
                                        *base.add(0).cast::<u8>() = (27i32) as u8;
                                        let vec18 = e;
                                        let ptr18 = vec18.as_ptr().cast::<u8>();
                                        let len18 = vec18.len();
                                        *base.add(12).cast::<usize>() = len18;
                                        *base.add(8).cast::<*mut u8>() = ptr18.cast_mut();
                                    }
                                    DbValue::Blob(e) => {
                                        *base.add(0).cast::<u8>() = (28i32) as u8;
                                        let vec19 = e;
                                        let ptr19 = vec19.as_ptr().cast::<u8>();
                                        let len19 = vec19.len();
                                        *base.add(12).cast::<usize>() = len19;
                                        *base.add(8).cast::<*mut u8>() = ptr19.cast_mut();
                                    }
                                    DbValue::Mediumblob(e) => {
                                        *base.add(0).cast::<u8>() = (29i32) as u8;
                                        let vec20 = e;
                                        let ptr20 = vec20.as_ptr().cast::<u8>();
                                        let len20 = vec20.len();
                                        *base.add(12).cast::<usize>() = len20;
                                        *base.add(8).cast::<*mut u8>() = ptr20.cast_mut();
                                    }
                                    DbValue::Longblob(e) => {
                                        *base.add(0).cast::<u8>() = (30i32) as u8;
                                        let vec21 = e;
                                        let ptr21 = vec21.as_ptr().cast::<u8>();
                                        let len21 = vec21.len();
                                        *base.add(12).cast::<usize>() = len21;
                                        *base.add(8).cast::<*mut u8>() = ptr21.cast_mut();
                                    }
                                    DbValue::Enumeration(e) => {
                                        *base.add(0).cast::<u8>() = (31i32) as u8;
                                        let vec22 = e;
                                        let ptr22 = vec22.as_ptr().cast::<u8>();
                                        let len22 = vec22.len();
                                        *base.add(12).cast::<usize>() = len22;
                                        *base.add(8).cast::<*mut u8>() = ptr22.cast_mut();
                                    }
                                    DbValue::Set(e) => {
                                        *base.add(0).cast::<u8>() = (32i32) as u8;
                                        let vec23 = e;
                                        let ptr23 = vec23.as_ptr().cast::<u8>();
                                        let len23 = vec23.len();
                                        *base.add(12).cast::<usize>() = len23;
                                        *base.add(8).cast::<*mut u8>() = ptr23.cast_mut();
                                    }
                                    DbValue::Bit(e) => {
                                        *base.add(0).cast::<u8>() = (33i32) as u8;
                                        let vec24 = e;
                                        let len24 = vec24.len();
                                        let layout24 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec24.len() * 1,
                                            1,
                                        );
                                        let result24 = if layout24.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout24).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout24);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec24.into_iter().enumerate() {
                                            let base = result24.add(i * 1);
                                            {
                                                *base.add(0).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len24;
                                        *base.add(8).cast::<*mut u8>() = result24;
                                        cleanup_list.extend_from_slice(&[(result24, layout24)]);
                                    }
                                    DbValue::Json(e) => {
                                        *base.add(0).cast::<u8>() = (34i32) as u8;
                                        let vec25 = e;
                                        let ptr25 = vec25.as_ptr().cast::<u8>();
                                        let len25 = vec25.len();
                                        *base.add(12).cast::<usize>() = len25;
                                        *base.add(8).cast::<*mut u8>() = ptr25.cast_mut();
                                    }
                                    DbValue::Null => {
                                        *base.add(0).cast::<u8>() = (35i32) as u8;
                                    }
                                }
                            }
                        }
                        let ptr27 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rdbms/mysql@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-connection.query"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            result26,
                            len26,
                            ptr27,
                        );
                        let l28 = i32::from(*ptr27.add(0).cast::<u8>());
                        if layout26.size() != 0 {
                            _rt::alloc::dealloc(result26.cast(), layout26);
                        }
                        for (ptr, layout) in cleanup_list {
                            if layout.size() != 0 {
                                _rt::alloc::dealloc(ptr.cast(), layout);
                            }
                        }
                        match l28 {
                            0 => {
                                let e = {
                                    let l29 = *ptr27.add(4).cast::<*mut u8>();
                                    let l30 = *ptr27.add(8).cast::<usize>();
                                    let base40 = l29;
                                    let len40 = l30;
                                    let mut result40 = _rt::Vec::with_capacity(len40);
                                    for i in 0..len40 {
                                        let base = base40.add(i * 32);
                                        let e40 = {
                                            let l31 = *base.add(0).cast::<i64>();
                                            let l32 = *base.add(8).cast::<*mut u8>();
                                            let l33 = *base.add(12).cast::<usize>();
                                            let len34 = l33;
                                            let bytes34 = _rt::Vec::from_raw_parts(
                                                l32.cast(),
                                                len34,
                                                len34,
                                            );
                                            let l35 = i32::from(*base.add(16).cast::<u8>());
                                            let v36 = match l35 {
                                                0 => DbColumnType::Boolean,
                                                1 => DbColumnType::Tinyint,
                                                2 => DbColumnType::Smallint,
                                                3 => DbColumnType::Mediumint,
                                                4 => DbColumnType::Int,
                                                5 => DbColumnType::Bigint,
                                                6 => DbColumnType::TinyintUnsigned,
                                                7 => DbColumnType::SmallintUnsigned,
                                                8 => DbColumnType::MediumintUnsigned,
                                                9 => DbColumnType::IntUnsigned,
                                                10 => DbColumnType::BigintUnsigned,
                                                11 => DbColumnType::Float,
                                                12 => DbColumnType::Double,
                                                13 => DbColumnType::Decimal,
                                                14 => DbColumnType::Date,
                                                15 => DbColumnType::Datetime,
                                                16 => DbColumnType::Timestamp,
                                                17 => DbColumnType::Time,
                                                18 => DbColumnType::Year,
                                                19 => DbColumnType::Fixchar,
                                                20 => DbColumnType::Varchar,
                                                21 => DbColumnType::Tinytext,
                                                22 => DbColumnType::Text,
                                                23 => DbColumnType::Mediumtext,
                                                24 => DbColumnType::Longtext,
                                                25 => DbColumnType::Binary,
                                                26 => DbColumnType::Varbinary,
                                                27 => DbColumnType::Tinyblob,
                                                28 => DbColumnType::Blob,
                                                29 => DbColumnType::Mediumblob,
                                                30 => DbColumnType::Longblob,
                                                31 => DbColumnType::Enumeration,
                                                32 => DbColumnType::Set,
                                                33 => DbColumnType::Bit,
                                                n => {
                                                    debug_assert_eq!(n, 34, "invalid enum discriminant");
                                                    DbColumnType::Json
                                                }
                                            };
                                            let l37 = *base.add(20).cast::<*mut u8>();
                                            let l38 = *base.add(24).cast::<usize>();
                                            let len39 = l38;
                                            let bytes39 = _rt::Vec::from_raw_parts(
                                                l37.cast(),
                                                len39,
                                                len39,
                                            );
                                            DbColumn {
                                                ordinal: l31 as u64,
                                                name: _rt::string_lift(bytes34),
                                                db_type: v36,
                                                db_type_name: _rt::string_lift(bytes39),
                                            }
                                        };
                                        result40.push(e40);
                                    }
                                    _rt::cabi_dealloc(base40, len40 * 32, 8);
                                    let l41 = *ptr27.add(12).cast::<*mut u8>();
                                    let l42 = *ptr27.add(16).cast::<usize>();
                                    let base135 = l41;
                                    let len135 = l42;
                                    let mut result135 = _rt::Vec::with_capacity(len135);
                                    for i in 0..len135 {
                                        let base = base135.add(i * 8);
                                        let e135 = {
                                            let l43 = *base.add(0).cast::<*mut u8>();
                                            let l44 = *base.add(4).cast::<usize>();
                                            let base134 = l43;
                                            let len134 = l44;
                                            let mut result134 = _rt::Vec::with_capacity(len134);
                                            for i in 0..len134 {
                                                let base = base134.add(i * 24);
                                                let e134 = {
                                                    let l45 = i32::from(*base.add(0).cast::<u8>());
                                                    let v133 = match l45 {
                                                        0 => {
                                                            let e133 = {
                                                                let l46 = i32::from(*base.add(8).cast::<u8>());
                                                                _rt::bool_lift(l46 as u8)
                                                            };
                                                            DbValue::Boolean(e133)
                                                        }
                                                        1 => {
                                                            let e133 = {
                                                                let l47 = i32::from(*base.add(8).cast::<i8>());
                                                                l47 as i8
                                                            };
                                                            DbValue::Tinyint(e133)
                                                        }
                                                        2 => {
                                                            let e133 = {
                                                                let l48 = i32::from(*base.add(8).cast::<i16>());
                                                                l48 as i16
                                                            };
                                                            DbValue::Smallint(e133)
                                                        }
                                                        3 => {
                                                            let e133 = {
                                                                let l49 = *base.add(8).cast::<i32>();
                                                                l49
                                                            };
                                                            DbValue::Mediumint(e133)
                                                        }
                                                        4 => {
                                                            let e133 = {
                                                                let l50 = *base.add(8).cast::<i32>();
                                                                l50
                                                            };
                                                            DbValue::Int(e133)
                                                        }
                                                        5 => {
                                                            let e133 = {
                                                                let l51 = *base.add(8).cast::<i64>();
                                                                l51
                                                            };
                                                            DbValue::Bigint(e133)
                                                        }
                                                        6 => {
                                                            let e133 = {
                                                                let l52 = i32::from(*base.add(8).cast::<u8>());
                                                                l52 as u8
                                                            };
                                                            DbValue::TinyintUnsigned(e133)
                                                        }
                                                        7 => {
                                                            let e133 = {
                                                                let l53 = i32::from(*base.add(8).cast::<u16>());
                                                                l53 as u16
                                                            };
                                                            DbValue::SmallintUnsigned(e133)
                                                        }
                                                        8 => {
                                                            let e133 = {
                                                                let l54 = *base.add(8).cast::<i32>();
                                                                l54 as u32
                                                            };
                                                            DbValue::MediumintUnsigned(e133)
                                                        }
                                                        9 => {
                                                            let e133 = {
                                                                let l55 = *base.add(8).cast::<i32>();
                                                                l55 as u32
                                                            };
                                                            DbValue::IntUnsigned(e133)
                                                        }
                                                        10 => {
                                                            let e133 = {
                                                                let l56 = *base.add(8).cast::<i64>();
                                                                l56 as u64
                                                            };
                                                            DbValue::BigintUnsigned(e133)
                                                        }
                                                        11 => {
                                                            let e133 = {
                                                                let l57 = *base.add(8).cast::<f32>();
                                                                l57
                                                            };
                                                            DbValue::Float(e133)
                                                        }
                                                        12 => {
                                                            let e133 = {
                                                                let l58 = *base.add(8).cast::<f64>();
                                                                l58
                                                            };
                                                            DbValue::Double(e133)
                                                        }
                                                        13 => {
                                                            let e133 = {
                                                                let l59 = *base.add(8).cast::<*mut u8>();
                                                                let l60 = *base.add(12).cast::<usize>();
                                                                let len61 = l60;
                                                                let bytes61 = _rt::Vec::from_raw_parts(
                                                                    l59.cast(),
                                                                    len61,
                                                                    len61,
                                                                );
                                                                _rt::string_lift(bytes61)
                                                            };
                                                            DbValue::Decimal(e133)
                                                        }
                                                        14 => {
                                                            let e133 = {
                                                                let l62 = *base.add(8).cast::<i32>();
                                                                let l63 = i32::from(*base.add(12).cast::<u8>());
                                                                let l64 = i32::from(*base.add(13).cast::<u8>());
                                                                super::super::super::golem::rdbms::types::Date {
                                                                    year: l62,
                                                                    month: l63 as u8,
                                                                    day: l64 as u8,
                                                                }
                                                            };
                                                            DbValue::Date(e133)
                                                        }
                                                        15 => {
                                                            let e133 = {
                                                                let l65 = *base.add(8).cast::<i32>();
                                                                let l66 = i32::from(*base.add(12).cast::<u8>());
                                                                let l67 = i32::from(*base.add(13).cast::<u8>());
                                                                let l68 = i32::from(*base.add(16).cast::<u8>());
                                                                let l69 = i32::from(*base.add(17).cast::<u8>());
                                                                let l70 = i32::from(*base.add(18).cast::<u8>());
                                                                let l71 = *base.add(20).cast::<i32>();
                                                                super::super::super::golem::rdbms::types::Timestamp {
                                                                    date: super::super::super::golem::rdbms::types::Date {
                                                                        year: l65,
                                                                        month: l66 as u8,
                                                                        day: l67 as u8,
                                                                    },
                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                        hour: l68 as u8,
                                                                        minute: l69 as u8,
                                                                        second: l70 as u8,
                                                                        nanosecond: l71 as u32,
                                                                    },
                                                                }
                                                            };
                                                            DbValue::Datetime(e133)
                                                        }
                                                        16 => {
                                                            let e133 = {
                                                                let l72 = *base.add(8).cast::<i32>();
                                                                let l73 = i32::from(*base.add(12).cast::<u8>());
                                                                let l74 = i32::from(*base.add(13).cast::<u8>());
                                                                let l75 = i32::from(*base.add(16).cast::<u8>());
                                                                let l76 = i32::from(*base.add(17).cast::<u8>());
                                                                let l77 = i32::from(*base.add(18).cast::<u8>());
                                                                let l78 = *base.add(20).cast::<i32>();
                                                                super::super::super::golem::rdbms::types::Timestamp {
                                                                    date: super::super::super::golem::rdbms::types::Date {
                                                                        year: l72,
                                                                        month: l73 as u8,
                                                                        day: l74 as u8,
                                                                    },
                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                        hour: l75 as u8,
                                                                        minute: l76 as u8,
                                                                        second: l77 as u8,
                                                                        nanosecond: l78 as u32,
                                                                    },
                                                                }
                                                            };
                                                            DbValue::Timestamp(e133)
                                                        }
                                                        17 => {
                                                            let e133 = {
                                                                let l79 = i32::from(*base.add(8).cast::<u8>());
                                                                let l80 = i32::from(*base.add(9).cast::<u8>());
                                                                let l81 = i32::from(*base.add(10).cast::<u8>());
                                                                let l82 = *base.add(12).cast::<i32>();
                                                                super::super::super::golem::rdbms::types::Time {
                                                                    hour: l79 as u8,
                                                                    minute: l80 as u8,
                                                                    second: l81 as u8,
                                                                    nanosecond: l82 as u32,
                                                                }
                                                            };
                                                            DbValue::Time(e133)
                                                        }
                                                        18 => {
                                                            let e133 = {
                                                                let l83 = i32::from(*base.add(8).cast::<u16>());
                                                                l83 as u16
                                                            };
                                                            DbValue::Year(e133)
                                                        }
                                                        19 => {
                                                            let e133 = {
                                                                let l84 = *base.add(8).cast::<*mut u8>();
                                                                let l85 = *base.add(12).cast::<usize>();
                                                                let len86 = l85;
                                                                let bytes86 = _rt::Vec::from_raw_parts(
                                                                    l84.cast(),
                                                                    len86,
                                                                    len86,
                                                                );
                                                                _rt::string_lift(bytes86)
                                                            };
                                                            DbValue::Fixchar(e133)
                                                        }
                                                        20 => {
                                                            let e133 = {
                                                                let l87 = *base.add(8).cast::<*mut u8>();
                                                                let l88 = *base.add(12).cast::<usize>();
                                                                let len89 = l88;
                                                                let bytes89 = _rt::Vec::from_raw_parts(
                                                                    l87.cast(),
                                                                    len89,
                                                                    len89,
                                                                );
                                                                _rt::string_lift(bytes89)
                                                            };
                                                            DbValue::Varchar(e133)
                                                        }
                                                        21 => {
                                                            let e133 = {
                                                                let l90 = *base.add(8).cast::<*mut u8>();
                                                                let l91 = *base.add(12).cast::<usize>();
                                                                let len92 = l91;
                                                                let bytes92 = _rt::Vec::from_raw_parts(
                                                                    l90.cast(),
                                                                    len92,
                                                                    len92,
                                                                );
                                                                _rt::string_lift(bytes92)
                                                            };
                                                            DbValue::Tinytext(e133)
                                                        }
                                                        22 => {
                                                            let e133 = {
                                                                let l93 = *base.add(8).cast::<*mut u8>();
                                                                let l94 = *base.add(12).cast::<usize>();
                                                                let len95 = l94;
                                                                let bytes95 = _rt::Vec::from_raw_parts(
                                                                    l93.cast(),
                                                                    len95,
                                                                    len95,
                                                                );
                                                                _rt::string_lift(bytes95)
                                                            };
                                                            DbValue::Text(e133)
                                                        }
                                                        23 => {
                                                            let e133 = {
                                                                let l96 = *base.add(8).cast::<*mut u8>();
                                                                let l97 = *base.add(12).cast::<usize>();
                                                                let len98 = l97;
                                                                let bytes98 = _rt::Vec::from_raw_parts(
                                                                    l96.cast(),
                                                                    len98,
                                                                    len98,
                                                                );
                                                                _rt::string_lift(bytes98)
                                                            };
                                                            DbValue::Mediumtext(e133)
                                                        }
                                                        24 => {
                                                            let e133 = {
                                                                let l99 = *base.add(8).cast::<*mut u8>();
                                                                let l100 = *base.add(12).cast::<usize>();
                                                                let len101 = l100;
                                                                let bytes101 = _rt::Vec::from_raw_parts(
                                                                    l99.cast(),
                                                                    len101,
                                                                    len101,
                                                                );
                                                                _rt::string_lift(bytes101)
                                                            };
                                                            DbValue::Longtext(e133)
                                                        }
                                                        25 => {
                                                            let e133 = {
                                                                let l102 = *base.add(8).cast::<*mut u8>();
                                                                let l103 = *base.add(12).cast::<usize>();
                                                                let len104 = l103;
                                                                _rt::Vec::from_raw_parts(l102.cast(), len104, len104)
                                                            };
                                                            DbValue::Binary(e133)
                                                        }
                                                        26 => {
                                                            let e133 = {
                                                                let l105 = *base.add(8).cast::<*mut u8>();
                                                                let l106 = *base.add(12).cast::<usize>();
                                                                let len107 = l106;
                                                                _rt::Vec::from_raw_parts(l105.cast(), len107, len107)
                                                            };
                                                            DbValue::Varbinary(e133)
                                                        }
                                                        27 => {
                                                            let e133 = {
                                                                let l108 = *base.add(8).cast::<*mut u8>();
                                                                let l109 = *base.add(12).cast::<usize>();
                                                                let len110 = l109;
                                                                _rt::Vec::from_raw_parts(l108.cast(), len110, len110)
                                                            };
                                                            DbValue::Tinyblob(e133)
                                                        }
                                                        28 => {
                                                            let e133 = {
                                                                let l111 = *base.add(8).cast::<*mut u8>();
                                                                let l112 = *base.add(12).cast::<usize>();
                                                                let len113 = l112;
                                                                _rt::Vec::from_raw_parts(l111.cast(), len113, len113)
                                                            };
                                                            DbValue::Blob(e133)
                                                        }
                                                        29 => {
                                                            let e133 = {
                                                                let l114 = *base.add(8).cast::<*mut u8>();
                                                                let l115 = *base.add(12).cast::<usize>();
                                                                let len116 = l115;
                                                                _rt::Vec::from_raw_parts(l114.cast(), len116, len116)
                                                            };
                                                            DbValue::Mediumblob(e133)
                                                        }
                                                        30 => {
                                                            let e133 = {
                                                                let l117 = *base.add(8).cast::<*mut u8>();
                                                                let l118 = *base.add(12).cast::<usize>();
                                                                let len119 = l118;
                                                                _rt::Vec::from_raw_parts(l117.cast(), len119, len119)
                                                            };
                                                            DbValue::Longblob(e133)
                                                        }
                                                        31 => {
                                                            let e133 = {
                                                                let l120 = *base.add(8).cast::<*mut u8>();
                                                                let l121 = *base.add(12).cast::<usize>();
                                                                let len122 = l121;
                                                                let bytes122 = _rt::Vec::from_raw_parts(
                                                                    l120.cast(),
                                                                    len122,
                                                                    len122,
                                                                );
                                                                _rt::string_lift(bytes122)
                                                            };
                                                            DbValue::Enumeration(e133)
                                                        }
                                                        32 => {
                                                            let e133 = {
                                                                let l123 = *base.add(8).cast::<*mut u8>();
                                                                let l124 = *base.add(12).cast::<usize>();
                                                                let len125 = l124;
                                                                let bytes125 = _rt::Vec::from_raw_parts(
                                                                    l123.cast(),
                                                                    len125,
                                                                    len125,
                                                                );
                                                                _rt::string_lift(bytes125)
                                                            };
                                                            DbValue::Set(e133)
                                                        }
                                                        33 => {
                                                            let e133 = {
                                                                let l126 = *base.add(8).cast::<*mut u8>();
                                                                let l127 = *base.add(12).cast::<usize>();
                                                                let base129 = l126;
                                                                let len129 = l127;
                                                                let mut result129 = _rt::Vec::with_capacity(len129);
                                                                for i in 0..len129 {
                                                                    let base = base129.add(i * 1);
                                                                    let e129 = {
                                                                        let l128 = i32::from(*base.add(0).cast::<u8>());
                                                                        _rt::bool_lift(l128 as u8)
                                                                    };
                                                                    result129.push(e129);
                                                                }
                                                                _rt::cabi_dealloc(base129, len129 * 1, 1);
                                                                result129
                                                            };
                                                            DbValue::Bit(e133)
                                                        }
                                                        34 => {
                                                            let e133 = {
                                                                let l130 = *base.add(8).cast::<*mut u8>();
                                                                let l131 = *base.add(12).cast::<usize>();
                                                                let len132 = l131;
                                                                let bytes132 = _rt::Vec::from_raw_parts(
                                                                    l130.cast(),
                                                                    len132,
                                                                    len132,
                                                                );
                                                                _rt::string_lift(bytes132)
                                                            };
                                                            DbValue::Json(e133)
                                                        }
                                                        n => {
                                                            debug_assert_eq!(n, 35, "invalid enum discriminant");
                                                            DbValue::Null
                                                        }
                                                    };
                                                    v133
                                                };
                                                result134.push(e134);
                                            }
                                            _rt::cabi_dealloc(base134, len134 * 24, 8);
                                            DbRow { values: result134 }
                                        };
                                        result135.push(e135);
                                    }
                                    _rt::cabi_dealloc(base135, len135 * 8, 4);
                                    DbResult {
                                        columns: result40,
                                        rows: result135,
                                    }
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l136 = i32::from(*ptr27.add(4).cast::<u8>());
                                    let v152 = match l136 {
                                        0 => {
                                            let e152 = {
                                                let l137 = *ptr27.add(8).cast::<*mut u8>();
                                                let l138 = *ptr27.add(12).cast::<usize>();
                                                let len139 = l138;
                                                let bytes139 = _rt::Vec::from_raw_parts(
                                                    l137.cast(),
                                                    len139,
                                                    len139,
                                                );
                                                _rt::string_lift(bytes139)
                                            };
                                            Error::ConnectionFailure(e152)
                                        }
                                        1 => {
                                            let e152 = {
                                                let l140 = *ptr27.add(8).cast::<*mut u8>();
                                                let l141 = *ptr27.add(12).cast::<usize>();
                                                let len142 = l141;
                                                let bytes142 = _rt::Vec::from_raw_parts(
                                                    l140.cast(),
                                                    len142,
                                                    len142,
                                                );
                                                _rt::string_lift(bytes142)
                                            };
                                            Error::QueryParameterFailure(e152)
                                        }
                                        2 => {
                                            let e152 = {
                                                let l143 = *ptr27.add(8).cast::<*mut u8>();
                                                let l144 = *ptr27.add(12).cast::<usize>();
                                                let len145 = l144;
                                                let bytes145 = _rt::Vec::from_raw_parts(
                                                    l143.cast(),
                                                    len145,
                                                    len145,
                                                );
                                                _rt::string_lift(bytes145)
                                            };
                                            Error::QueryExecutionFailure(e152)
                                        }
                                        3 => {
                                            let e152 = {
                                                let l146 = *ptr27.add(8).cast::<*mut u8>();
                                                let l147 = *ptr27.add(12).cast::<usize>();
                                                let len148 = l147;
                                                let bytes148 = _rt::Vec::from_raw_parts(
                                                    l146.cast(),
                                                    len148,
                                                    len148,
                                                );
                                                _rt::string_lift(bytes148)
                                            };
                                            Error::QueryResponseFailure(e152)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 4, "invalid enum discriminant");
                                            let e152 = {
                                                let l149 = *ptr27.add(8).cast::<*mut u8>();
                                                let l150 = *ptr27.add(12).cast::<usize>();
                                                let len151 = l150;
                                                let bytes151 = _rt::Vec::from_raw_parts(
                                                    l149.cast(),
                                                    len151,
                                                    len151,
                                                );
                                                _rt::string_lift(bytes151)
                                            };
                                            Error::Other(e152)
                                        }
                                    };
                                    v152
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl DbConnection {
                #[allow(unused_unsafe, clippy::all)]
                pub fn query_stream(
                    &self,
                    statement: &str,
                    params: &[DbValue],
                ) -> Result<DbResultStream, Error> {
                    unsafe {
                        let mut cleanup_list = _rt::Vec::new();
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 16]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 16],
                        );
                        let vec0 = statement;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let vec26 = params;
                        let len26 = vec26.len();
                        let layout26 = _rt::alloc::Layout::from_size_align_unchecked(
                            vec26.len() * 24,
                            8,
                        );
                        let result26 = if layout26.size() != 0 {
                            let ptr = _rt::alloc::alloc(layout26).cast::<u8>();
                            if ptr.is_null() {
                                _rt::alloc::handle_alloc_error(layout26);
                            }
                            ptr
                        } else {
                            ::core::ptr::null_mut()
                        };
                        for (i, e) in vec26.into_iter().enumerate() {
                            let base = result26.add(i * 24);
                            {
                                match e {
                                    DbValue::Boolean(e) => {
                                        *base.add(0).cast::<u8>() = (0i32) as u8;
                                        *base.add(8).cast::<u8>() = (match e {
                                            true => 1,
                                            false => 0,
                                        }) as u8;
                                    }
                                    DbValue::Tinyint(e) => {
                                        *base.add(0).cast::<u8>() = (1i32) as u8;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                    }
                                    DbValue::Smallint(e) => {
                                        *base.add(0).cast::<u8>() = (2i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::Mediumint(e) => {
                                        *base.add(0).cast::<u8>() = (3i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Int(e) => {
                                        *base.add(0).cast::<u8>() = (4i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Bigint(e) => {
                                        *base.add(0).cast::<u8>() = (5i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::TinyintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (6i32) as u8;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                    }
                                    DbValue::SmallintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (7i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::MediumintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (8i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::IntUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (9i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::BigintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (10i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::Float(e) => {
                                        *base.add(0).cast::<u8>() = (11i32) as u8;
                                        *base.add(8).cast::<f32>() = _rt::as_f32(e);
                                    }
                                    DbValue::Double(e) => {
                                        *base.add(0).cast::<u8>() = (12i32) as u8;
                                        *base.add(8).cast::<f64>() = _rt::as_f64(e);
                                    }
                                    DbValue::Decimal(e) => {
                                        *base.add(0).cast::<u8>() = (13i32) as u8;
                                        let vec1 = e;
                                        let ptr1 = vec1.as_ptr().cast::<u8>();
                                        let len1 = vec1.len();
                                        *base.add(12).cast::<usize>() = len1;
                                        *base.add(8).cast::<*mut u8>() = ptr1.cast_mut();
                                    }
                                    DbValue::Date(e) => {
                                        *base.add(0).cast::<u8>() = (14i32) as u8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year2,
                                            month: month2,
                                            day: day2,
                                        } = e;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year2);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month2)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day2)) as u8;
                                    }
                                    DbValue::Datetime(e) => {
                                        *base.add(0).cast::<u8>() = (15i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date3,
                                            time: time3,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year4,
                                            month: month4,
                                            day: day4,
                                        } = date3;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year4);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month4)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day4)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour5,
                                            minute: minute5,
                                            second: second5,
                                            nanosecond: nanosecond5,
                                        } = time3;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour5)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute5)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second5)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond5);
                                    }
                                    DbValue::Timestamp(e) => {
                                        *base.add(0).cast::<u8>() = (16i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date6,
                                            time: time6,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year7,
                                            month: month7,
                                            day: day7,
                                        } = date6;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year7);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month7)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day7)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour8,
                                            minute: minute8,
                                            second: second8,
                                            nanosecond: nanosecond8,
                                        } = time6;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour8)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute8)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second8)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond8);
                                    }
                                    DbValue::Time(e) => {
                                        *base.add(0).cast::<u8>() = (17i32) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour9,
                                            minute: minute9,
                                            second: second9,
                                            nanosecond: nanosecond9,
                                        } = e;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(hour9)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(minute9)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(second9)) as u8;
                                        *base.add(12).cast::<i32>() = _rt::as_i32(nanosecond9);
                                    }
                                    DbValue::Year(e) => {
                                        *base.add(0).cast::<u8>() = (18i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::Fixchar(e) => {
                                        *base.add(0).cast::<u8>() = (19i32) as u8;
                                        let vec10 = e;
                                        let ptr10 = vec10.as_ptr().cast::<u8>();
                                        let len10 = vec10.len();
                                        *base.add(12).cast::<usize>() = len10;
                                        *base.add(8).cast::<*mut u8>() = ptr10.cast_mut();
                                    }
                                    DbValue::Varchar(e) => {
                                        *base.add(0).cast::<u8>() = (20i32) as u8;
                                        let vec11 = e;
                                        let ptr11 = vec11.as_ptr().cast::<u8>();
                                        let len11 = vec11.len();
                                        *base.add(12).cast::<usize>() = len11;
                                        *base.add(8).cast::<*mut u8>() = ptr11.cast_mut();
                                    }
                                    DbValue::Tinytext(e) => {
                                        *base.add(0).cast::<u8>() = (21i32) as u8;
                                        let vec12 = e;
                                        let ptr12 = vec12.as_ptr().cast::<u8>();
                                        let len12 = vec12.len();
                                        *base.add(12).cast::<usize>() = len12;
                                        *base.add(8).cast::<*mut u8>() = ptr12.cast_mut();
                                    }
                                    DbValue::Text(e) => {
                                        *base.add(0).cast::<u8>() = (22i32) as u8;
                                        let vec13 = e;
                                        let ptr13 = vec13.as_ptr().cast::<u8>();
                                        let len13 = vec13.len();
                                        *base.add(12).cast::<usize>() = len13;
                                        *base.add(8).cast::<*mut u8>() = ptr13.cast_mut();
                                    }
                                    DbValue::Mediumtext(e) => {
                                        *base.add(0).cast::<u8>() = (23i32) as u8;
                                        let vec14 = e;
                                        let ptr14 = vec14.as_ptr().cast::<u8>();
                                        let len14 = vec14.len();
                                        *base.add(12).cast::<usize>() = len14;
                                        *base.add(8).cast::<*mut u8>() = ptr14.cast_mut();
                                    }
                                    DbValue::Longtext(e) => {
                                        *base.add(0).cast::<u8>() = (24i32) as u8;
                                        let vec15 = e;
                                        let ptr15 = vec15.as_ptr().cast::<u8>();
                                        let len15 = vec15.len();
                                        *base.add(12).cast::<usize>() = len15;
                                        *base.add(8).cast::<*mut u8>() = ptr15.cast_mut();
                                    }
                                    DbValue::Binary(e) => {
                                        *base.add(0).cast::<u8>() = (25i32) as u8;
                                        let vec16 = e;
                                        let ptr16 = vec16.as_ptr().cast::<u8>();
                                        let len16 = vec16.len();
                                        *base.add(12).cast::<usize>() = len16;
                                        *base.add(8).cast::<*mut u8>() = ptr16.cast_mut();
                                    }
                                    DbValue::Varbinary(e) => {
                                        *base.add(0).cast::<u8>() = (26i32) as u8;
                                        let vec17 = e;
                                        let ptr17 = vec17.as_ptr().cast::<u8>();
                                        let len17 = vec17.len();
                                        *base.add(12).cast::<usize>() = len17;
                                        *base.add(8).cast::<*mut u8>() = ptr17.cast_mut();
                                    }
                                    DbValue::Tinyblob(e) => {
                                        *base.add(0).cast::<u8>() = (27i32) as u8;
                                        let vec18 = e;
                                        let ptr18 = vec18.as_ptr().cast::<u8>();
                                        let len18 = vec18.len();
                                        *base.add(12).cast::<usize>() = len18;
                                        *base.add(8).cast::<*mut u8>() = ptr18.cast_mut();
                                    }
                                    DbValue::Blob(e) => {
                                        *base.add(0).cast::<u8>() = (28i32) as u8;
                                        let vec19 = e;
                                        let ptr19 = vec19.as_ptr().cast::<u8>();
                                        let len19 = vec19.len();
                                        *base.add(12).cast::<usize>() = len19;
                                        *base.add(8).cast::<*mut u8>() = ptr19.cast_mut();
                                    }
                                    DbValue::Mediumblob(e) => {
                                        *base.add(0).cast::<u8>() = (29i32) as u8;
                                        let vec20 = e;
                                        let ptr20 = vec20.as_ptr().cast::<u8>();
                                        let len20 = vec20.len();
                                        *base.add(12).cast::<usize>() = len20;
                                        *base.add(8).cast::<*mut u8>() = ptr20.cast_mut();
                                    }
                                    DbValue::Longblob(e) => {
                                        *base.add(0).cast::<u8>() = (30i32) as u8;
                                        let vec21 = e;
                                        let ptr21 = vec21.as_ptr().cast::<u8>();
                                        let len21 = vec21.len();
                                        *base.add(12).cast::<usize>() = len21;
                                        *base.add(8).cast::<*mut u8>() = ptr21.cast_mut();
                                    }
                                    DbValue::Enumeration(e) => {
                                        *base.add(0).cast::<u8>() = (31i32) as u8;
                                        let vec22 = e;
                                        let ptr22 = vec22.as_ptr().cast::<u8>();
                                        let len22 = vec22.len();
                                        *base.add(12).cast::<usize>() = len22;
                                        *base.add(8).cast::<*mut u8>() = ptr22.cast_mut();
                                    }
                                    DbValue::Set(e) => {
                                        *base.add(0).cast::<u8>() = (32i32) as u8;
                                        let vec23 = e;
                                        let ptr23 = vec23.as_ptr().cast::<u8>();
                                        let len23 = vec23.len();
                                        *base.add(12).cast::<usize>() = len23;
                                        *base.add(8).cast::<*mut u8>() = ptr23.cast_mut();
                                    }
                                    DbValue::Bit(e) => {
                                        *base.add(0).cast::<u8>() = (33i32) as u8;
                                        let vec24 = e;
                                        let len24 = vec24.len();
                                        let layout24 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec24.len() * 1,
                                            1,
                                        );
                                        let result24 = if layout24.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout24).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout24);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec24.into_iter().enumerate() {
                                            let base = result24.add(i * 1);
                                            {
                                                *base.add(0).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len24;
                                        *base.add(8).cast::<*mut u8>() = result24;
                                        cleanup_list.extend_from_slice(&[(result24, layout24)]);
                                    }
                                    DbValue::Json(e) => {
                                        *base.add(0).cast::<u8>() = (34i32) as u8;
                                        let vec25 = e;
                                        let ptr25 = vec25.as_ptr().cast::<u8>();
                                        let len25 = vec25.len();
                                        *base.add(12).cast::<usize>() = len25;
                                        *base.add(8).cast::<*mut u8>() = ptr25.cast_mut();
                                    }
                                    DbValue::Null => {
                                        *base.add(0).cast::<u8>() = (35i32) as u8;
                                    }
                                }
                            }
                        }
                        let ptr27 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rdbms/mysql@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-connection.query-stream"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            result26,
                            len26,
                            ptr27,
                        );
                        let l28 = i32::from(*ptr27.add(0).cast::<u8>());
                        if layout26.size() != 0 {
                            _rt::alloc::dealloc(result26.cast(), layout26);
                        }
                        for (ptr, layout) in cleanup_list {
                            if layout.size() != 0 {
                                _rt::alloc::dealloc(ptr.cast(), layout);
                            }
                        }
                        match l28 {
                            0 => {
                                let e = {
                                    let l29 = *ptr27.add(4).cast::<i32>();
                                    DbResultStream::from_handle(l29 as u32)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l30 = i32::from(*ptr27.add(4).cast::<u8>());
                                    let v46 = match l30 {
                                        0 => {
                                            let e46 = {
                                                let l31 = *ptr27.add(8).cast::<*mut u8>();
                                                let l32 = *ptr27.add(12).cast::<usize>();
                                                let len33 = l32;
                                                let bytes33 = _rt::Vec::from_raw_parts(
                                                    l31.cast(),
                                                    len33,
                                                    len33,
                                                );
                                                _rt::string_lift(bytes33)
                                            };
                                            Error::ConnectionFailure(e46)
                                        }
                                        1 => {
                                            let e46 = {
                                                let l34 = *ptr27.add(8).cast::<*mut u8>();
                                                let l35 = *ptr27.add(12).cast::<usize>();
                                                let len36 = l35;
                                                let bytes36 = _rt::Vec::from_raw_parts(
                                                    l34.cast(),
                                                    len36,
                                                    len36,
                                                );
                                                _rt::string_lift(bytes36)
                                            };
                                            Error::QueryParameterFailure(e46)
                                        }
                                        2 => {
                                            let e46 = {
                                                let l37 = *ptr27.add(8).cast::<*mut u8>();
                                                let l38 = *ptr27.add(12).cast::<usize>();
                                                let len39 = l38;
                                                let bytes39 = _rt::Vec::from_raw_parts(
                                                    l37.cast(),
                                                    len39,
                                                    len39,
                                                );
                                                _rt::string_lift(bytes39)
                                            };
                                            Error::QueryExecutionFailure(e46)
                                        }
                                        3 => {
                                            let e46 = {
                                                let l40 = *ptr27.add(8).cast::<*mut u8>();
                                                let l41 = *ptr27.add(12).cast::<usize>();
                                                let len42 = l41;
                                                let bytes42 = _rt::Vec::from_raw_parts(
                                                    l40.cast(),
                                                    len42,
                                                    len42,
                                                );
                                                _rt::string_lift(bytes42)
                                            };
                                            Error::QueryResponseFailure(e46)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 4, "invalid enum discriminant");
                                            let e46 = {
                                                let l43 = *ptr27.add(8).cast::<*mut u8>();
                                                let l44 = *ptr27.add(12).cast::<usize>();
                                                let len45 = l44;
                                                let bytes45 = _rt::Vec::from_raw_parts(
                                                    l43.cast(),
                                                    len45,
                                                    len45,
                                                );
                                                _rt::string_lift(bytes45)
                                            };
                                            Error::Other(e46)
                                        }
                                    };
                                    v46
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl DbConnection {
                #[allow(unused_unsafe, clippy::all)]
                pub fn execute(
                    &self,
                    statement: &str,
                    params: &[DbValue],
                ) -> Result<u64, Error> {
                    unsafe {
                        let mut cleanup_list = _rt::Vec::new();
                        #[repr(align(8))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 24]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 24],
                        );
                        let vec0 = statement;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let vec26 = params;
                        let len26 = vec26.len();
                        let layout26 = _rt::alloc::Layout::from_size_align_unchecked(
                            vec26.len() * 24,
                            8,
                        );
                        let result26 = if layout26.size() != 0 {
                            let ptr = _rt::alloc::alloc(layout26).cast::<u8>();
                            if ptr.is_null() {
                                _rt::alloc::handle_alloc_error(layout26);
                            }
                            ptr
                        } else {
                            ::core::ptr::null_mut()
                        };
                        for (i, e) in vec26.into_iter().enumerate() {
                            let base = result26.add(i * 24);
                            {
                                match e {
                                    DbValue::Boolean(e) => {
                                        *base.add(0).cast::<u8>() = (0i32) as u8;
                                        *base.add(8).cast::<u8>() = (match e {
                                            true => 1,
                                            false => 0,
                                        }) as u8;
                                    }
                                    DbValue::Tinyint(e) => {
                                        *base.add(0).cast::<u8>() = (1i32) as u8;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                    }
                                    DbValue::Smallint(e) => {
                                        *base.add(0).cast::<u8>() = (2i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::Mediumint(e) => {
                                        *base.add(0).cast::<u8>() = (3i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Int(e) => {
                                        *base.add(0).cast::<u8>() = (4i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Bigint(e) => {
                                        *base.add(0).cast::<u8>() = (5i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::TinyintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (6i32) as u8;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                    }
                                    DbValue::SmallintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (7i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::MediumintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (8i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::IntUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (9i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::BigintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (10i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::Float(e) => {
                                        *base.add(0).cast::<u8>() = (11i32) as u8;
                                        *base.add(8).cast::<f32>() = _rt::as_f32(e);
                                    }
                                    DbValue::Double(e) => {
                                        *base.add(0).cast::<u8>() = (12i32) as u8;
                                        *base.add(8).cast::<f64>() = _rt::as_f64(e);
                                    }
                                    DbValue::Decimal(e) => {
                                        *base.add(0).cast::<u8>() = (13i32) as u8;
                                        let vec1 = e;
                                        let ptr1 = vec1.as_ptr().cast::<u8>();
                                        let len1 = vec1.len();
                                        *base.add(12).cast::<usize>() = len1;
                                        *base.add(8).cast::<*mut u8>() = ptr1.cast_mut();
                                    }
                                    DbValue::Date(e) => {
                                        *base.add(0).cast::<u8>() = (14i32) as u8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year2,
                                            month: month2,
                                            day: day2,
                                        } = e;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year2);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month2)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day2)) as u8;
                                    }
                                    DbValue::Datetime(e) => {
                                        *base.add(0).cast::<u8>() = (15i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date3,
                                            time: time3,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year4,
                                            month: month4,
                                            day: day4,
                                        } = date3;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year4);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month4)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day4)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour5,
                                            minute: minute5,
                                            second: second5,
                                            nanosecond: nanosecond5,
                                        } = time3;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour5)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute5)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second5)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond5);
                                    }
                                    DbValue::Timestamp(e) => {
                                        *base.add(0).cast::<u8>() = (16i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date6,
                                            time: time6,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year7,
                                            month: month7,
                                            day: day7,
                                        } = date6;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year7);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month7)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day7)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour8,
                                            minute: minute8,
                                            second: second8,
                                            nanosecond: nanosecond8,
                                        } = time6;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour8)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute8)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second8)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond8);
                                    }
                                    DbValue::Time(e) => {
                                        *base.add(0).cast::<u8>() = (17i32) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour9,
                                            minute: minute9,
                                            second: second9,
                                            nanosecond: nanosecond9,
                                        } = e;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(hour9)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(minute9)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(second9)) as u8;
                                        *base.add(12).cast::<i32>() = _rt::as_i32(nanosecond9);
                                    }
                                    DbValue::Year(e) => {
                                        *base.add(0).cast::<u8>() = (18i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::Fixchar(e) => {
                                        *base.add(0).cast::<u8>() = (19i32) as u8;
                                        let vec10 = e;
                                        let ptr10 = vec10.as_ptr().cast::<u8>();
                                        let len10 = vec10.len();
                                        *base.add(12).cast::<usize>() = len10;
                                        *base.add(8).cast::<*mut u8>() = ptr10.cast_mut();
                                    }
                                    DbValue::Varchar(e) => {
                                        *base.add(0).cast::<u8>() = (20i32) as u8;
                                        let vec11 = e;
                                        let ptr11 = vec11.as_ptr().cast::<u8>();
                                        let len11 = vec11.len();
                                        *base.add(12).cast::<usize>() = len11;
                                        *base.add(8).cast::<*mut u8>() = ptr11.cast_mut();
                                    }
                                    DbValue::Tinytext(e) => {
                                        *base.add(0).cast::<u8>() = (21i32) as u8;
                                        let vec12 = e;
                                        let ptr12 = vec12.as_ptr().cast::<u8>();
                                        let len12 = vec12.len();
                                        *base.add(12).cast::<usize>() = len12;
                                        *base.add(8).cast::<*mut u8>() = ptr12.cast_mut();
                                    }
                                    DbValue::Text(e) => {
                                        *base.add(0).cast::<u8>() = (22i32) as u8;
                                        let vec13 = e;
                                        let ptr13 = vec13.as_ptr().cast::<u8>();
                                        let len13 = vec13.len();
                                        *base.add(12).cast::<usize>() = len13;
                                        *base.add(8).cast::<*mut u8>() = ptr13.cast_mut();
                                    }
                                    DbValue::Mediumtext(e) => {
                                        *base.add(0).cast::<u8>() = (23i32) as u8;
                                        let vec14 = e;
                                        let ptr14 = vec14.as_ptr().cast::<u8>();
                                        let len14 = vec14.len();
                                        *base.add(12).cast::<usize>() = len14;
                                        *base.add(8).cast::<*mut u8>() = ptr14.cast_mut();
                                    }
                                    DbValue::Longtext(e) => {
                                        *base.add(0).cast::<u8>() = (24i32) as u8;
                                        let vec15 = e;
                                        let ptr15 = vec15.as_ptr().cast::<u8>();
                                        let len15 = vec15.len();
                                        *base.add(12).cast::<usize>() = len15;
                                        *base.add(8).cast::<*mut u8>() = ptr15.cast_mut();
                                    }
                                    DbValue::Binary(e) => {
                                        *base.add(0).cast::<u8>() = (25i32) as u8;
                                        let vec16 = e;
                                        let ptr16 = vec16.as_ptr().cast::<u8>();
                                        let len16 = vec16.len();
                                        *base.add(12).cast::<usize>() = len16;
                                        *base.add(8).cast::<*mut u8>() = ptr16.cast_mut();
                                    }
                                    DbValue::Varbinary(e) => {
                                        *base.add(0).cast::<u8>() = (26i32) as u8;
                                        let vec17 = e;
                                        let ptr17 = vec17.as_ptr().cast::<u8>();
                                        let len17 = vec17.len();
                                        *base.add(12).cast::<usize>() = len17;
                                        *base.add(8).cast::<*mut u8>() = ptr17.cast_mut();
                                    }
                                    DbValue::Tinyblob(e) => {
                                        *base.add(0).cast::<u8>() = (27i32) as u8;
                                        let vec18 = e;
                                        let ptr18 = vec18.as_ptr().cast::<u8>();
                                        let len18 = vec18.len();
                                        *base.add(12).cast::<usize>() = len18;
                                        *base.add(8).cast::<*mut u8>() = ptr18.cast_mut();
                                    }
                                    DbValue::Blob(e) => {
                                        *base.add(0).cast::<u8>() = (28i32) as u8;
                                        let vec19 = e;
                                        let ptr19 = vec19.as_ptr().cast::<u8>();
                                        let len19 = vec19.len();
                                        *base.add(12).cast::<usize>() = len19;
                                        *base.add(8).cast::<*mut u8>() = ptr19.cast_mut();
                                    }
                                    DbValue::Mediumblob(e) => {
                                        *base.add(0).cast::<u8>() = (29i32) as u8;
                                        let vec20 = e;
                                        let ptr20 = vec20.as_ptr().cast::<u8>();
                                        let len20 = vec20.len();
                                        *base.add(12).cast::<usize>() = len20;
                                        *base.add(8).cast::<*mut u8>() = ptr20.cast_mut();
                                    }
                                    DbValue::Longblob(e) => {
                                        *base.add(0).cast::<u8>() = (30i32) as u8;
                                        let vec21 = e;
                                        let ptr21 = vec21.as_ptr().cast::<u8>();
                                        let len21 = vec21.len();
                                        *base.add(12).cast::<usize>() = len21;
                                        *base.add(8).cast::<*mut u8>() = ptr21.cast_mut();
                                    }
                                    DbValue::Enumeration(e) => {
                                        *base.add(0).cast::<u8>() = (31i32) as u8;
                                        let vec22 = e;
                                        let ptr22 = vec22.as_ptr().cast::<u8>();
                                        let len22 = vec22.len();
                                        *base.add(12).cast::<usize>() = len22;
                                        *base.add(8).cast::<*mut u8>() = ptr22.cast_mut();
                                    }
                                    DbValue::Set(e) => {
                                        *base.add(0).cast::<u8>() = (32i32) as u8;
                                        let vec23 = e;
                                        let ptr23 = vec23.as_ptr().cast::<u8>();
                                        let len23 = vec23.len();
                                        *base.add(12).cast::<usize>() = len23;
                                        *base.add(8).cast::<*mut u8>() = ptr23.cast_mut();
                                    }
                                    DbValue::Bit(e) => {
                                        *base.add(0).cast::<u8>() = (33i32) as u8;
                                        let vec24 = e;
                                        let len24 = vec24.len();
                                        let layout24 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec24.len() * 1,
                                            1,
                                        );
                                        let result24 = if layout24.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout24).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout24);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec24.into_iter().enumerate() {
                                            let base = result24.add(i * 1);
                                            {
                                                *base.add(0).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len24;
                                        *base.add(8).cast::<*mut u8>() = result24;
                                        cleanup_list.extend_from_slice(&[(result24, layout24)]);
                                    }
                                    DbValue::Json(e) => {
                                        *base.add(0).cast::<u8>() = (34i32) as u8;
                                        let vec25 = e;
                                        let ptr25 = vec25.as_ptr().cast::<u8>();
                                        let len25 = vec25.len();
                                        *base.add(12).cast::<usize>() = len25;
                                        *base.add(8).cast::<*mut u8>() = ptr25.cast_mut();
                                    }
                                    DbValue::Null => {
                                        *base.add(0).cast::<u8>() = (35i32) as u8;
                                    }
                                }
                            }
                        }
                        let ptr27 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rdbms/mysql@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-connection.execute"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            result26,
                            len26,
                            ptr27,
                        );
                        let l28 = i32::from(*ptr27.add(0).cast::<u8>());
                        if layout26.size() != 0 {
                            _rt::alloc::dealloc(result26.cast(), layout26);
                        }
                        for (ptr, layout) in cleanup_list {
                            if layout.size() != 0 {
                                _rt::alloc::dealloc(ptr.cast(), layout);
                            }
                        }
                        match l28 {
                            0 => {
                                let e = {
                                    let l29 = *ptr27.add(8).cast::<i64>();
                                    l29 as u64
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l30 = i32::from(*ptr27.add(8).cast::<u8>());
                                    let v46 = match l30 {
                                        0 => {
                                            let e46 = {
                                                let l31 = *ptr27.add(12).cast::<*mut u8>();
                                                let l32 = *ptr27.add(16).cast::<usize>();
                                                let len33 = l32;
                                                let bytes33 = _rt::Vec::from_raw_parts(
                                                    l31.cast(),
                                                    len33,
                                                    len33,
                                                );
                                                _rt::string_lift(bytes33)
                                            };
                                            Error::ConnectionFailure(e46)
                                        }
                                        1 => {
                                            let e46 = {
                                                let l34 = *ptr27.add(12).cast::<*mut u8>();
                                                let l35 = *ptr27.add(16).cast::<usize>();
                                                let len36 = l35;
                                                let bytes36 = _rt::Vec::from_raw_parts(
                                                    l34.cast(),
                                                    len36,
                                                    len36,
                                                );
                                                _rt::string_lift(bytes36)
                                            };
                                            Error::QueryParameterFailure(e46)
                                        }
                                        2 => {
                                            let e46 = {
                                                let l37 = *ptr27.add(12).cast::<*mut u8>();
                                                let l38 = *ptr27.add(16).cast::<usize>();
                                                let len39 = l38;
                                                let bytes39 = _rt::Vec::from_raw_parts(
                                                    l37.cast(),
                                                    len39,
                                                    len39,
                                                );
                                                _rt::string_lift(bytes39)
                                            };
                                            Error::QueryExecutionFailure(e46)
                                        }
                                        3 => {
                                            let e46 = {
                                                let l40 = *ptr27.add(12).cast::<*mut u8>();
                                                let l41 = *ptr27.add(16).cast::<usize>();
                                                let len42 = l41;
                                                let bytes42 = _rt::Vec::from_raw_parts(
                                                    l40.cast(),
                                                    len42,
                                                    len42,
                                                );
                                                _rt::string_lift(bytes42)
                                            };
                                            Error::QueryResponseFailure(e46)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 4, "invalid enum discriminant");
                                            let e46 = {
                                                let l43 = *ptr27.add(12).cast::<*mut u8>();
                                                let l44 = *ptr27.add(16).cast::<usize>();
                                                let len45 = l44;
                                                let bytes45 = _rt::Vec::from_raw_parts(
                                                    l43.cast(),
                                                    len45,
                                                    len45,
                                                );
                                                _rt::string_lift(bytes45)
                                            };
                                            Error::Other(e46)
                                        }
                                    };
                                    v46
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl DbConnection {
                #[allow(unused_unsafe, clippy::all)]
                pub fn begin_transaction(&self) -> Result<DbTransaction, Error> {
                    unsafe {
                        #[repr(align(4))]
                        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 = "golem:rdbms/mysql@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-connection.begin-transaction"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<i32>();
                                    DbTransaction::from_handle(l2 as u32)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = i32::from(*ptr0.add(4).cast::<u8>());
                                    let v19 = match l3 {
                                        0 => {
                                            let e19 = {
                                                let l4 = *ptr0.add(8).cast::<*mut u8>();
                                                let l5 = *ptr0.add(12).cast::<usize>();
                                                let len6 = l5;
                                                let bytes6 = _rt::Vec::from_raw_parts(
                                                    l4.cast(),
                                                    len6,
                                                    len6,
                                                );
                                                _rt::string_lift(bytes6)
                                            };
                                            Error::ConnectionFailure(e19)
                                        }
                                        1 => {
                                            let e19 = {
                                                let l7 = *ptr0.add(8).cast::<*mut u8>();
                                                let l8 = *ptr0.add(12).cast::<usize>();
                                                let len9 = l8;
                                                let bytes9 = _rt::Vec::from_raw_parts(
                                                    l7.cast(),
                                                    len9,
                                                    len9,
                                                );
                                                _rt::string_lift(bytes9)
                                            };
                                            Error::QueryParameterFailure(e19)
                                        }
                                        2 => {
                                            let e19 = {
                                                let l10 = *ptr0.add(8).cast::<*mut u8>();
                                                let l11 = *ptr0.add(12).cast::<usize>();
                                                let len12 = l11;
                                                let bytes12 = _rt::Vec::from_raw_parts(
                                                    l10.cast(),
                                                    len12,
                                                    len12,
                                                );
                                                _rt::string_lift(bytes12)
                                            };
                                            Error::QueryExecutionFailure(e19)
                                        }
                                        3 => {
                                            let e19 = {
                                                let l13 = *ptr0.add(8).cast::<*mut u8>();
                                                let l14 = *ptr0.add(12).cast::<usize>();
                                                let len15 = l14;
                                                let bytes15 = _rt::Vec::from_raw_parts(
                                                    l13.cast(),
                                                    len15,
                                                    len15,
                                                );
                                                _rt::string_lift(bytes15)
                                            };
                                            Error::QueryResponseFailure(e19)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 4, "invalid enum discriminant");
                                            let e19 = {
                                                let l16 = *ptr0.add(8).cast::<*mut u8>();
                                                let l17 = *ptr0.add(12).cast::<usize>();
                                                let len18 = l17;
                                                let bytes18 = _rt::Vec::from_raw_parts(
                                                    l16.cast(),
                                                    len18,
                                                    len18,
                                                );
                                                _rt::string_lift(bytes18)
                                            };
                                            Error::Other(e19)
                                        }
                                    };
                                    v19
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl DbTransaction {
                #[allow(unused_unsafe, clippy::all)]
                pub fn query(
                    &self,
                    statement: &str,
                    params: &[DbValue],
                ) -> Result<DbResult, Error> {
                    unsafe {
                        let mut cleanup_list = _rt::Vec::new();
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 20]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 20],
                        );
                        let vec0 = statement;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let vec26 = params;
                        let len26 = vec26.len();
                        let layout26 = _rt::alloc::Layout::from_size_align_unchecked(
                            vec26.len() * 24,
                            8,
                        );
                        let result26 = if layout26.size() != 0 {
                            let ptr = _rt::alloc::alloc(layout26).cast::<u8>();
                            if ptr.is_null() {
                                _rt::alloc::handle_alloc_error(layout26);
                            }
                            ptr
                        } else {
                            ::core::ptr::null_mut()
                        };
                        for (i, e) in vec26.into_iter().enumerate() {
                            let base = result26.add(i * 24);
                            {
                                match e {
                                    DbValue::Boolean(e) => {
                                        *base.add(0).cast::<u8>() = (0i32) as u8;
                                        *base.add(8).cast::<u8>() = (match e {
                                            true => 1,
                                            false => 0,
                                        }) as u8;
                                    }
                                    DbValue::Tinyint(e) => {
                                        *base.add(0).cast::<u8>() = (1i32) as u8;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                    }
                                    DbValue::Smallint(e) => {
                                        *base.add(0).cast::<u8>() = (2i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::Mediumint(e) => {
                                        *base.add(0).cast::<u8>() = (3i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Int(e) => {
                                        *base.add(0).cast::<u8>() = (4i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Bigint(e) => {
                                        *base.add(0).cast::<u8>() = (5i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::TinyintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (6i32) as u8;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                    }
                                    DbValue::SmallintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (7i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::MediumintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (8i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::IntUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (9i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::BigintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (10i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::Float(e) => {
                                        *base.add(0).cast::<u8>() = (11i32) as u8;
                                        *base.add(8).cast::<f32>() = _rt::as_f32(e);
                                    }
                                    DbValue::Double(e) => {
                                        *base.add(0).cast::<u8>() = (12i32) as u8;
                                        *base.add(8).cast::<f64>() = _rt::as_f64(e);
                                    }
                                    DbValue::Decimal(e) => {
                                        *base.add(0).cast::<u8>() = (13i32) as u8;
                                        let vec1 = e;
                                        let ptr1 = vec1.as_ptr().cast::<u8>();
                                        let len1 = vec1.len();
                                        *base.add(12).cast::<usize>() = len1;
                                        *base.add(8).cast::<*mut u8>() = ptr1.cast_mut();
                                    }
                                    DbValue::Date(e) => {
                                        *base.add(0).cast::<u8>() = (14i32) as u8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year2,
                                            month: month2,
                                            day: day2,
                                        } = e;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year2);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month2)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day2)) as u8;
                                    }
                                    DbValue::Datetime(e) => {
                                        *base.add(0).cast::<u8>() = (15i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date3,
                                            time: time3,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year4,
                                            month: month4,
                                            day: day4,
                                        } = date3;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year4);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month4)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day4)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour5,
                                            minute: minute5,
                                            second: second5,
                                            nanosecond: nanosecond5,
                                        } = time3;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour5)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute5)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second5)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond5);
                                    }
                                    DbValue::Timestamp(e) => {
                                        *base.add(0).cast::<u8>() = (16i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date6,
                                            time: time6,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year7,
                                            month: month7,
                                            day: day7,
                                        } = date6;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year7);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month7)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day7)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour8,
                                            minute: minute8,
                                            second: second8,
                                            nanosecond: nanosecond8,
                                        } = time6;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour8)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute8)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second8)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond8);
                                    }
                                    DbValue::Time(e) => {
                                        *base.add(0).cast::<u8>() = (17i32) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour9,
                                            minute: minute9,
                                            second: second9,
                                            nanosecond: nanosecond9,
                                        } = e;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(hour9)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(minute9)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(second9)) as u8;
                                        *base.add(12).cast::<i32>() = _rt::as_i32(nanosecond9);
                                    }
                                    DbValue::Year(e) => {
                                        *base.add(0).cast::<u8>() = (18i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::Fixchar(e) => {
                                        *base.add(0).cast::<u8>() = (19i32) as u8;
                                        let vec10 = e;
                                        let ptr10 = vec10.as_ptr().cast::<u8>();
                                        let len10 = vec10.len();
                                        *base.add(12).cast::<usize>() = len10;
                                        *base.add(8).cast::<*mut u8>() = ptr10.cast_mut();
                                    }
                                    DbValue::Varchar(e) => {
                                        *base.add(0).cast::<u8>() = (20i32) as u8;
                                        let vec11 = e;
                                        let ptr11 = vec11.as_ptr().cast::<u8>();
                                        let len11 = vec11.len();
                                        *base.add(12).cast::<usize>() = len11;
                                        *base.add(8).cast::<*mut u8>() = ptr11.cast_mut();
                                    }
                                    DbValue::Tinytext(e) => {
                                        *base.add(0).cast::<u8>() = (21i32) as u8;
                                        let vec12 = e;
                                        let ptr12 = vec12.as_ptr().cast::<u8>();
                                        let len12 = vec12.len();
                                        *base.add(12).cast::<usize>() = len12;
                                        *base.add(8).cast::<*mut u8>() = ptr12.cast_mut();
                                    }
                                    DbValue::Text(e) => {
                                        *base.add(0).cast::<u8>() = (22i32) as u8;
                                        let vec13 = e;
                                        let ptr13 = vec13.as_ptr().cast::<u8>();
                                        let len13 = vec13.len();
                                        *base.add(12).cast::<usize>() = len13;
                                        *base.add(8).cast::<*mut u8>() = ptr13.cast_mut();
                                    }
                                    DbValue::Mediumtext(e) => {
                                        *base.add(0).cast::<u8>() = (23i32) as u8;
                                        let vec14 = e;
                                        let ptr14 = vec14.as_ptr().cast::<u8>();
                                        let len14 = vec14.len();
                                        *base.add(12).cast::<usize>() = len14;
                                        *base.add(8).cast::<*mut u8>() = ptr14.cast_mut();
                                    }
                                    DbValue::Longtext(e) => {
                                        *base.add(0).cast::<u8>() = (24i32) as u8;
                                        let vec15 = e;
                                        let ptr15 = vec15.as_ptr().cast::<u8>();
                                        let len15 = vec15.len();
                                        *base.add(12).cast::<usize>() = len15;
                                        *base.add(8).cast::<*mut u8>() = ptr15.cast_mut();
                                    }
                                    DbValue::Binary(e) => {
                                        *base.add(0).cast::<u8>() = (25i32) as u8;
                                        let vec16 = e;
                                        let ptr16 = vec16.as_ptr().cast::<u8>();
                                        let len16 = vec16.len();
                                        *base.add(12).cast::<usize>() = len16;
                                        *base.add(8).cast::<*mut u8>() = ptr16.cast_mut();
                                    }
                                    DbValue::Varbinary(e) => {
                                        *base.add(0).cast::<u8>() = (26i32) as u8;
                                        let vec17 = e;
                                        let ptr17 = vec17.as_ptr().cast::<u8>();
                                        let len17 = vec17.len();
                                        *base.add(12).cast::<usize>() = len17;
                                        *base.add(8).cast::<*mut u8>() = ptr17.cast_mut();
                                    }
                                    DbValue::Tinyblob(e) => {
                                        *base.add(0).cast::<u8>() = (27i32) as u8;
                                        let vec18 = e;
                                        let ptr18 = vec18.as_ptr().cast::<u8>();
                                        let len18 = vec18.len();
                                        *base.add(12).cast::<usize>() = len18;
                                        *base.add(8).cast::<*mut u8>() = ptr18.cast_mut();
                                    }
                                    DbValue::Blob(e) => {
                                        *base.add(0).cast::<u8>() = (28i32) as u8;
                                        let vec19 = e;
                                        let ptr19 = vec19.as_ptr().cast::<u8>();
                                        let len19 = vec19.len();
                                        *base.add(12).cast::<usize>() = len19;
                                        *base.add(8).cast::<*mut u8>() = ptr19.cast_mut();
                                    }
                                    DbValue::Mediumblob(e) => {
                                        *base.add(0).cast::<u8>() = (29i32) as u8;
                                        let vec20 = e;
                                        let ptr20 = vec20.as_ptr().cast::<u8>();
                                        let len20 = vec20.len();
                                        *base.add(12).cast::<usize>() = len20;
                                        *base.add(8).cast::<*mut u8>() = ptr20.cast_mut();
                                    }
                                    DbValue::Longblob(e) => {
                                        *base.add(0).cast::<u8>() = (30i32) as u8;
                                        let vec21 = e;
                                        let ptr21 = vec21.as_ptr().cast::<u8>();
                                        let len21 = vec21.len();
                                        *base.add(12).cast::<usize>() = len21;
                                        *base.add(8).cast::<*mut u8>() = ptr21.cast_mut();
                                    }
                                    DbValue::Enumeration(e) => {
                                        *base.add(0).cast::<u8>() = (31i32) as u8;
                                        let vec22 = e;
                                        let ptr22 = vec22.as_ptr().cast::<u8>();
                                        let len22 = vec22.len();
                                        *base.add(12).cast::<usize>() = len22;
                                        *base.add(8).cast::<*mut u8>() = ptr22.cast_mut();
                                    }
                                    DbValue::Set(e) => {
                                        *base.add(0).cast::<u8>() = (32i32) as u8;
                                        let vec23 = e;
                                        let ptr23 = vec23.as_ptr().cast::<u8>();
                                        let len23 = vec23.len();
                                        *base.add(12).cast::<usize>() = len23;
                                        *base.add(8).cast::<*mut u8>() = ptr23.cast_mut();
                                    }
                                    DbValue::Bit(e) => {
                                        *base.add(0).cast::<u8>() = (33i32) as u8;
                                        let vec24 = e;
                                        let len24 = vec24.len();
                                        let layout24 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec24.len() * 1,
                                            1,
                                        );
                                        let result24 = if layout24.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout24).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout24);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec24.into_iter().enumerate() {
                                            let base = result24.add(i * 1);
                                            {
                                                *base.add(0).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len24;
                                        *base.add(8).cast::<*mut u8>() = result24;
                                        cleanup_list.extend_from_slice(&[(result24, layout24)]);
                                    }
                                    DbValue::Json(e) => {
                                        *base.add(0).cast::<u8>() = (34i32) as u8;
                                        let vec25 = e;
                                        let ptr25 = vec25.as_ptr().cast::<u8>();
                                        let len25 = vec25.len();
                                        *base.add(12).cast::<usize>() = len25;
                                        *base.add(8).cast::<*mut u8>() = ptr25.cast_mut();
                                    }
                                    DbValue::Null => {
                                        *base.add(0).cast::<u8>() = (35i32) as u8;
                                    }
                                }
                            }
                        }
                        let ptr27 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rdbms/mysql@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-transaction.query"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            result26,
                            len26,
                            ptr27,
                        );
                        let l28 = i32::from(*ptr27.add(0).cast::<u8>());
                        if layout26.size() != 0 {
                            _rt::alloc::dealloc(result26.cast(), layout26);
                        }
                        for (ptr, layout) in cleanup_list {
                            if layout.size() != 0 {
                                _rt::alloc::dealloc(ptr.cast(), layout);
                            }
                        }
                        match l28 {
                            0 => {
                                let e = {
                                    let l29 = *ptr27.add(4).cast::<*mut u8>();
                                    let l30 = *ptr27.add(8).cast::<usize>();
                                    let base40 = l29;
                                    let len40 = l30;
                                    let mut result40 = _rt::Vec::with_capacity(len40);
                                    for i in 0..len40 {
                                        let base = base40.add(i * 32);
                                        let e40 = {
                                            let l31 = *base.add(0).cast::<i64>();
                                            let l32 = *base.add(8).cast::<*mut u8>();
                                            let l33 = *base.add(12).cast::<usize>();
                                            let len34 = l33;
                                            let bytes34 = _rt::Vec::from_raw_parts(
                                                l32.cast(),
                                                len34,
                                                len34,
                                            );
                                            let l35 = i32::from(*base.add(16).cast::<u8>());
                                            let v36 = match l35 {
                                                0 => DbColumnType::Boolean,
                                                1 => DbColumnType::Tinyint,
                                                2 => DbColumnType::Smallint,
                                                3 => DbColumnType::Mediumint,
                                                4 => DbColumnType::Int,
                                                5 => DbColumnType::Bigint,
                                                6 => DbColumnType::TinyintUnsigned,
                                                7 => DbColumnType::SmallintUnsigned,
                                                8 => DbColumnType::MediumintUnsigned,
                                                9 => DbColumnType::IntUnsigned,
                                                10 => DbColumnType::BigintUnsigned,
                                                11 => DbColumnType::Float,
                                                12 => DbColumnType::Double,
                                                13 => DbColumnType::Decimal,
                                                14 => DbColumnType::Date,
                                                15 => DbColumnType::Datetime,
                                                16 => DbColumnType::Timestamp,
                                                17 => DbColumnType::Time,
                                                18 => DbColumnType::Year,
                                                19 => DbColumnType::Fixchar,
                                                20 => DbColumnType::Varchar,
                                                21 => DbColumnType::Tinytext,
                                                22 => DbColumnType::Text,
                                                23 => DbColumnType::Mediumtext,
                                                24 => DbColumnType::Longtext,
                                                25 => DbColumnType::Binary,
                                                26 => DbColumnType::Varbinary,
                                                27 => DbColumnType::Tinyblob,
                                                28 => DbColumnType::Blob,
                                                29 => DbColumnType::Mediumblob,
                                                30 => DbColumnType::Longblob,
                                                31 => DbColumnType::Enumeration,
                                                32 => DbColumnType::Set,
                                                33 => DbColumnType::Bit,
                                                n => {
                                                    debug_assert_eq!(n, 34, "invalid enum discriminant");
                                                    DbColumnType::Json
                                                }
                                            };
                                            let l37 = *base.add(20).cast::<*mut u8>();
                                            let l38 = *base.add(24).cast::<usize>();
                                            let len39 = l38;
                                            let bytes39 = _rt::Vec::from_raw_parts(
                                                l37.cast(),
                                                len39,
                                                len39,
                                            );
                                            DbColumn {
                                                ordinal: l31 as u64,
                                                name: _rt::string_lift(bytes34),
                                                db_type: v36,
                                                db_type_name: _rt::string_lift(bytes39),
                                            }
                                        };
                                        result40.push(e40);
                                    }
                                    _rt::cabi_dealloc(base40, len40 * 32, 8);
                                    let l41 = *ptr27.add(12).cast::<*mut u8>();
                                    let l42 = *ptr27.add(16).cast::<usize>();
                                    let base135 = l41;
                                    let len135 = l42;
                                    let mut result135 = _rt::Vec::with_capacity(len135);
                                    for i in 0..len135 {
                                        let base = base135.add(i * 8);
                                        let e135 = {
                                            let l43 = *base.add(0).cast::<*mut u8>();
                                            let l44 = *base.add(4).cast::<usize>();
                                            let base134 = l43;
                                            let len134 = l44;
                                            let mut result134 = _rt::Vec::with_capacity(len134);
                                            for i in 0..len134 {
                                                let base = base134.add(i * 24);
                                                let e134 = {
                                                    let l45 = i32::from(*base.add(0).cast::<u8>());
                                                    let v133 = match l45 {
                                                        0 => {
                                                            let e133 = {
                                                                let l46 = i32::from(*base.add(8).cast::<u8>());
                                                                _rt::bool_lift(l46 as u8)
                                                            };
                                                            DbValue::Boolean(e133)
                                                        }
                                                        1 => {
                                                            let e133 = {
                                                                let l47 = i32::from(*base.add(8).cast::<i8>());
                                                                l47 as i8
                                                            };
                                                            DbValue::Tinyint(e133)
                                                        }
                                                        2 => {
                                                            let e133 = {
                                                                let l48 = i32::from(*base.add(8).cast::<i16>());
                                                                l48 as i16
                                                            };
                                                            DbValue::Smallint(e133)
                                                        }
                                                        3 => {
                                                            let e133 = {
                                                                let l49 = *base.add(8).cast::<i32>();
                                                                l49
                                                            };
                                                            DbValue::Mediumint(e133)
                                                        }
                                                        4 => {
                                                            let e133 = {
                                                                let l50 = *base.add(8).cast::<i32>();
                                                                l50
                                                            };
                                                            DbValue::Int(e133)
                                                        }
                                                        5 => {
                                                            let e133 = {
                                                                let l51 = *base.add(8).cast::<i64>();
                                                                l51
                                                            };
                                                            DbValue::Bigint(e133)
                                                        }
                                                        6 => {
                                                            let e133 = {
                                                                let l52 = i32::from(*base.add(8).cast::<u8>());
                                                                l52 as u8
                                                            };
                                                            DbValue::TinyintUnsigned(e133)
                                                        }
                                                        7 => {
                                                            let e133 = {
                                                                let l53 = i32::from(*base.add(8).cast::<u16>());
                                                                l53 as u16
                                                            };
                                                            DbValue::SmallintUnsigned(e133)
                                                        }
                                                        8 => {
                                                            let e133 = {
                                                                let l54 = *base.add(8).cast::<i32>();
                                                                l54 as u32
                                                            };
                                                            DbValue::MediumintUnsigned(e133)
                                                        }
                                                        9 => {
                                                            let e133 = {
                                                                let l55 = *base.add(8).cast::<i32>();
                                                                l55 as u32
                                                            };
                                                            DbValue::IntUnsigned(e133)
                                                        }
                                                        10 => {
                                                            let e133 = {
                                                                let l56 = *base.add(8).cast::<i64>();
                                                                l56 as u64
                                                            };
                                                            DbValue::BigintUnsigned(e133)
                                                        }
                                                        11 => {
                                                            let e133 = {
                                                                let l57 = *base.add(8).cast::<f32>();
                                                                l57
                                                            };
                                                            DbValue::Float(e133)
                                                        }
                                                        12 => {
                                                            let e133 = {
                                                                let l58 = *base.add(8).cast::<f64>();
                                                                l58
                                                            };
                                                            DbValue::Double(e133)
                                                        }
                                                        13 => {
                                                            let e133 = {
                                                                let l59 = *base.add(8).cast::<*mut u8>();
                                                                let l60 = *base.add(12).cast::<usize>();
                                                                let len61 = l60;
                                                                let bytes61 = _rt::Vec::from_raw_parts(
                                                                    l59.cast(),
                                                                    len61,
                                                                    len61,
                                                                );
                                                                _rt::string_lift(bytes61)
                                                            };
                                                            DbValue::Decimal(e133)
                                                        }
                                                        14 => {
                                                            let e133 = {
                                                                let l62 = *base.add(8).cast::<i32>();
                                                                let l63 = i32::from(*base.add(12).cast::<u8>());
                                                                let l64 = i32::from(*base.add(13).cast::<u8>());
                                                                super::super::super::golem::rdbms::types::Date {
                                                                    year: l62,
                                                                    month: l63 as u8,
                                                                    day: l64 as u8,
                                                                }
                                                            };
                                                            DbValue::Date(e133)
                                                        }
                                                        15 => {
                                                            let e133 = {
                                                                let l65 = *base.add(8).cast::<i32>();
                                                                let l66 = i32::from(*base.add(12).cast::<u8>());
                                                                let l67 = i32::from(*base.add(13).cast::<u8>());
                                                                let l68 = i32::from(*base.add(16).cast::<u8>());
                                                                let l69 = i32::from(*base.add(17).cast::<u8>());
                                                                let l70 = i32::from(*base.add(18).cast::<u8>());
                                                                let l71 = *base.add(20).cast::<i32>();
                                                                super::super::super::golem::rdbms::types::Timestamp {
                                                                    date: super::super::super::golem::rdbms::types::Date {
                                                                        year: l65,
                                                                        month: l66 as u8,
                                                                        day: l67 as u8,
                                                                    },
                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                        hour: l68 as u8,
                                                                        minute: l69 as u8,
                                                                        second: l70 as u8,
                                                                        nanosecond: l71 as u32,
                                                                    },
                                                                }
                                                            };
                                                            DbValue::Datetime(e133)
                                                        }
                                                        16 => {
                                                            let e133 = {
                                                                let l72 = *base.add(8).cast::<i32>();
                                                                let l73 = i32::from(*base.add(12).cast::<u8>());
                                                                let l74 = i32::from(*base.add(13).cast::<u8>());
                                                                let l75 = i32::from(*base.add(16).cast::<u8>());
                                                                let l76 = i32::from(*base.add(17).cast::<u8>());
                                                                let l77 = i32::from(*base.add(18).cast::<u8>());
                                                                let l78 = *base.add(20).cast::<i32>();
                                                                super::super::super::golem::rdbms::types::Timestamp {
                                                                    date: super::super::super::golem::rdbms::types::Date {
                                                                        year: l72,
                                                                        month: l73 as u8,
                                                                        day: l74 as u8,
                                                                    },
                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                        hour: l75 as u8,
                                                                        minute: l76 as u8,
                                                                        second: l77 as u8,
                                                                        nanosecond: l78 as u32,
                                                                    },
                                                                }
                                                            };
                                                            DbValue::Timestamp(e133)
                                                        }
                                                        17 => {
                                                            let e133 = {
                                                                let l79 = i32::from(*base.add(8).cast::<u8>());
                                                                let l80 = i32::from(*base.add(9).cast::<u8>());
                                                                let l81 = i32::from(*base.add(10).cast::<u8>());
                                                                let l82 = *base.add(12).cast::<i32>();
                                                                super::super::super::golem::rdbms::types::Time {
                                                                    hour: l79 as u8,
                                                                    minute: l80 as u8,
                                                                    second: l81 as u8,
                                                                    nanosecond: l82 as u32,
                                                                }
                                                            };
                                                            DbValue::Time(e133)
                                                        }
                                                        18 => {
                                                            let e133 = {
                                                                let l83 = i32::from(*base.add(8).cast::<u16>());
                                                                l83 as u16
                                                            };
                                                            DbValue::Year(e133)
                                                        }
                                                        19 => {
                                                            let e133 = {
                                                                let l84 = *base.add(8).cast::<*mut u8>();
                                                                let l85 = *base.add(12).cast::<usize>();
                                                                let len86 = l85;
                                                                let bytes86 = _rt::Vec::from_raw_parts(
                                                                    l84.cast(),
                                                                    len86,
                                                                    len86,
                                                                );
                                                                _rt::string_lift(bytes86)
                                                            };
                                                            DbValue::Fixchar(e133)
                                                        }
                                                        20 => {
                                                            let e133 = {
                                                                let l87 = *base.add(8).cast::<*mut u8>();
                                                                let l88 = *base.add(12).cast::<usize>();
                                                                let len89 = l88;
                                                                let bytes89 = _rt::Vec::from_raw_parts(
                                                                    l87.cast(),
                                                                    len89,
                                                                    len89,
                                                                );
                                                                _rt::string_lift(bytes89)
                                                            };
                                                            DbValue::Varchar(e133)
                                                        }
                                                        21 => {
                                                            let e133 = {
                                                                let l90 = *base.add(8).cast::<*mut u8>();
                                                                let l91 = *base.add(12).cast::<usize>();
                                                                let len92 = l91;
                                                                let bytes92 = _rt::Vec::from_raw_parts(
                                                                    l90.cast(),
                                                                    len92,
                                                                    len92,
                                                                );
                                                                _rt::string_lift(bytes92)
                                                            };
                                                            DbValue::Tinytext(e133)
                                                        }
                                                        22 => {
                                                            let e133 = {
                                                                let l93 = *base.add(8).cast::<*mut u8>();
                                                                let l94 = *base.add(12).cast::<usize>();
                                                                let len95 = l94;
                                                                let bytes95 = _rt::Vec::from_raw_parts(
                                                                    l93.cast(),
                                                                    len95,
                                                                    len95,
                                                                );
                                                                _rt::string_lift(bytes95)
                                                            };
                                                            DbValue::Text(e133)
                                                        }
                                                        23 => {
                                                            let e133 = {
                                                                let l96 = *base.add(8).cast::<*mut u8>();
                                                                let l97 = *base.add(12).cast::<usize>();
                                                                let len98 = l97;
                                                                let bytes98 = _rt::Vec::from_raw_parts(
                                                                    l96.cast(),
                                                                    len98,
                                                                    len98,
                                                                );
                                                                _rt::string_lift(bytes98)
                                                            };
                                                            DbValue::Mediumtext(e133)
                                                        }
                                                        24 => {
                                                            let e133 = {
                                                                let l99 = *base.add(8).cast::<*mut u8>();
                                                                let l100 = *base.add(12).cast::<usize>();
                                                                let len101 = l100;
                                                                let bytes101 = _rt::Vec::from_raw_parts(
                                                                    l99.cast(),
                                                                    len101,
                                                                    len101,
                                                                );
                                                                _rt::string_lift(bytes101)
                                                            };
                                                            DbValue::Longtext(e133)
                                                        }
                                                        25 => {
                                                            let e133 = {
                                                                let l102 = *base.add(8).cast::<*mut u8>();
                                                                let l103 = *base.add(12).cast::<usize>();
                                                                let len104 = l103;
                                                                _rt::Vec::from_raw_parts(l102.cast(), len104, len104)
                                                            };
                                                            DbValue::Binary(e133)
                                                        }
                                                        26 => {
                                                            let e133 = {
                                                                let l105 = *base.add(8).cast::<*mut u8>();
                                                                let l106 = *base.add(12).cast::<usize>();
                                                                let len107 = l106;
                                                                _rt::Vec::from_raw_parts(l105.cast(), len107, len107)
                                                            };
                                                            DbValue::Varbinary(e133)
                                                        }
                                                        27 => {
                                                            let e133 = {
                                                                let l108 = *base.add(8).cast::<*mut u8>();
                                                                let l109 = *base.add(12).cast::<usize>();
                                                                let len110 = l109;
                                                                _rt::Vec::from_raw_parts(l108.cast(), len110, len110)
                                                            };
                                                            DbValue::Tinyblob(e133)
                                                        }
                                                        28 => {
                                                            let e133 = {
                                                                let l111 = *base.add(8).cast::<*mut u8>();
                                                                let l112 = *base.add(12).cast::<usize>();
                                                                let len113 = l112;
                                                                _rt::Vec::from_raw_parts(l111.cast(), len113, len113)
                                                            };
                                                            DbValue::Blob(e133)
                                                        }
                                                        29 => {
                                                            let e133 = {
                                                                let l114 = *base.add(8).cast::<*mut u8>();
                                                                let l115 = *base.add(12).cast::<usize>();
                                                                let len116 = l115;
                                                                _rt::Vec::from_raw_parts(l114.cast(), len116, len116)
                                                            };
                                                            DbValue::Mediumblob(e133)
                                                        }
                                                        30 => {
                                                            let e133 = {
                                                                let l117 = *base.add(8).cast::<*mut u8>();
                                                                let l118 = *base.add(12).cast::<usize>();
                                                                let len119 = l118;
                                                                _rt::Vec::from_raw_parts(l117.cast(), len119, len119)
                                                            };
                                                            DbValue::Longblob(e133)
                                                        }
                                                        31 => {
                                                            let e133 = {
                                                                let l120 = *base.add(8).cast::<*mut u8>();
                                                                let l121 = *base.add(12).cast::<usize>();
                                                                let len122 = l121;
                                                                let bytes122 = _rt::Vec::from_raw_parts(
                                                                    l120.cast(),
                                                                    len122,
                                                                    len122,
                                                                );
                                                                _rt::string_lift(bytes122)
                                                            };
                                                            DbValue::Enumeration(e133)
                                                        }
                                                        32 => {
                                                            let e133 = {
                                                                let l123 = *base.add(8).cast::<*mut u8>();
                                                                let l124 = *base.add(12).cast::<usize>();
                                                                let len125 = l124;
                                                                let bytes125 = _rt::Vec::from_raw_parts(
                                                                    l123.cast(),
                                                                    len125,
                                                                    len125,
                                                                );
                                                                _rt::string_lift(bytes125)
                                                            };
                                                            DbValue::Set(e133)
                                                        }
                                                        33 => {
                                                            let e133 = {
                                                                let l126 = *base.add(8).cast::<*mut u8>();
                                                                let l127 = *base.add(12).cast::<usize>();
                                                                let base129 = l126;
                                                                let len129 = l127;
                                                                let mut result129 = _rt::Vec::with_capacity(len129);
                                                                for i in 0..len129 {
                                                                    let base = base129.add(i * 1);
                                                                    let e129 = {
                                                                        let l128 = i32::from(*base.add(0).cast::<u8>());
                                                                        _rt::bool_lift(l128 as u8)
                                                                    };
                                                                    result129.push(e129);
                                                                }
                                                                _rt::cabi_dealloc(base129, len129 * 1, 1);
                                                                result129
                                                            };
                                                            DbValue::Bit(e133)
                                                        }
                                                        34 => {
                                                            let e133 = {
                                                                let l130 = *base.add(8).cast::<*mut u8>();
                                                                let l131 = *base.add(12).cast::<usize>();
                                                                let len132 = l131;
                                                                let bytes132 = _rt::Vec::from_raw_parts(
                                                                    l130.cast(),
                                                                    len132,
                                                                    len132,
                                                                );
                                                                _rt::string_lift(bytes132)
                                                            };
                                                            DbValue::Json(e133)
                                                        }
                                                        n => {
                                                            debug_assert_eq!(n, 35, "invalid enum discriminant");
                                                            DbValue::Null
                                                        }
                                                    };
                                                    v133
                                                };
                                                result134.push(e134);
                                            }
                                            _rt::cabi_dealloc(base134, len134 * 24, 8);
                                            DbRow { values: result134 }
                                        };
                                        result135.push(e135);
                                    }
                                    _rt::cabi_dealloc(base135, len135 * 8, 4);
                                    DbResult {
                                        columns: result40,
                                        rows: result135,
                                    }
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l136 = i32::from(*ptr27.add(4).cast::<u8>());
                                    let v152 = match l136 {
                                        0 => {
                                            let e152 = {
                                                let l137 = *ptr27.add(8).cast::<*mut u8>();
                                                let l138 = *ptr27.add(12).cast::<usize>();
                                                let len139 = l138;
                                                let bytes139 = _rt::Vec::from_raw_parts(
                                                    l137.cast(),
                                                    len139,
                                                    len139,
                                                );
                                                _rt::string_lift(bytes139)
                                            };
                                            Error::ConnectionFailure(e152)
                                        }
                                        1 => {
                                            let e152 = {
                                                let l140 = *ptr27.add(8).cast::<*mut u8>();
                                                let l141 = *ptr27.add(12).cast::<usize>();
                                                let len142 = l141;
                                                let bytes142 = _rt::Vec::from_raw_parts(
                                                    l140.cast(),
                                                    len142,
                                                    len142,
                                                );
                                                _rt::string_lift(bytes142)
                                            };
                                            Error::QueryParameterFailure(e152)
                                        }
                                        2 => {
                                            let e152 = {
                                                let l143 = *ptr27.add(8).cast::<*mut u8>();
                                                let l144 = *ptr27.add(12).cast::<usize>();
                                                let len145 = l144;
                                                let bytes145 = _rt::Vec::from_raw_parts(
                                                    l143.cast(),
                                                    len145,
                                                    len145,
                                                );
                                                _rt::string_lift(bytes145)
                                            };
                                            Error::QueryExecutionFailure(e152)
                                        }
                                        3 => {
                                            let e152 = {
                                                let l146 = *ptr27.add(8).cast::<*mut u8>();
                                                let l147 = *ptr27.add(12).cast::<usize>();
                                                let len148 = l147;
                                                let bytes148 = _rt::Vec::from_raw_parts(
                                                    l146.cast(),
                                                    len148,
                                                    len148,
                                                );
                                                _rt::string_lift(bytes148)
                                            };
                                            Error::QueryResponseFailure(e152)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 4, "invalid enum discriminant");
                                            let e152 = {
                                                let l149 = *ptr27.add(8).cast::<*mut u8>();
                                                let l150 = *ptr27.add(12).cast::<usize>();
                                                let len151 = l150;
                                                let bytes151 = _rt::Vec::from_raw_parts(
                                                    l149.cast(),
                                                    len151,
                                                    len151,
                                                );
                                                _rt::string_lift(bytes151)
                                            };
                                            Error::Other(e152)
                                        }
                                    };
                                    v152
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl DbTransaction {
                #[allow(unused_unsafe, clippy::all)]
                pub fn query_stream(
                    &self,
                    statement: &str,
                    params: &[DbValue],
                ) -> Result<DbResultStream, Error> {
                    unsafe {
                        let mut cleanup_list = _rt::Vec::new();
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 16]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 16],
                        );
                        let vec0 = statement;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let vec26 = params;
                        let len26 = vec26.len();
                        let layout26 = _rt::alloc::Layout::from_size_align_unchecked(
                            vec26.len() * 24,
                            8,
                        );
                        let result26 = if layout26.size() != 0 {
                            let ptr = _rt::alloc::alloc(layout26).cast::<u8>();
                            if ptr.is_null() {
                                _rt::alloc::handle_alloc_error(layout26);
                            }
                            ptr
                        } else {
                            ::core::ptr::null_mut()
                        };
                        for (i, e) in vec26.into_iter().enumerate() {
                            let base = result26.add(i * 24);
                            {
                                match e {
                                    DbValue::Boolean(e) => {
                                        *base.add(0).cast::<u8>() = (0i32) as u8;
                                        *base.add(8).cast::<u8>() = (match e {
                                            true => 1,
                                            false => 0,
                                        }) as u8;
                                    }
                                    DbValue::Tinyint(e) => {
                                        *base.add(0).cast::<u8>() = (1i32) as u8;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                    }
                                    DbValue::Smallint(e) => {
                                        *base.add(0).cast::<u8>() = (2i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::Mediumint(e) => {
                                        *base.add(0).cast::<u8>() = (3i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Int(e) => {
                                        *base.add(0).cast::<u8>() = (4i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Bigint(e) => {
                                        *base.add(0).cast::<u8>() = (5i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::TinyintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (6i32) as u8;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                    }
                                    DbValue::SmallintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (7i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::MediumintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (8i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::IntUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (9i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::BigintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (10i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::Float(e) => {
                                        *base.add(0).cast::<u8>() = (11i32) as u8;
                                        *base.add(8).cast::<f32>() = _rt::as_f32(e);
                                    }
                                    DbValue::Double(e) => {
                                        *base.add(0).cast::<u8>() = (12i32) as u8;
                                        *base.add(8).cast::<f64>() = _rt::as_f64(e);
                                    }
                                    DbValue::Decimal(e) => {
                                        *base.add(0).cast::<u8>() = (13i32) as u8;
                                        let vec1 = e;
                                        let ptr1 = vec1.as_ptr().cast::<u8>();
                                        let len1 = vec1.len();
                                        *base.add(12).cast::<usize>() = len1;
                                        *base.add(8).cast::<*mut u8>() = ptr1.cast_mut();
                                    }
                                    DbValue::Date(e) => {
                                        *base.add(0).cast::<u8>() = (14i32) as u8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year2,
                                            month: month2,
                                            day: day2,
                                        } = e;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year2);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month2)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day2)) as u8;
                                    }
                                    DbValue::Datetime(e) => {
                                        *base.add(0).cast::<u8>() = (15i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date3,
                                            time: time3,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year4,
                                            month: month4,
                                            day: day4,
                                        } = date3;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year4);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month4)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day4)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour5,
                                            minute: minute5,
                                            second: second5,
                                            nanosecond: nanosecond5,
                                        } = time3;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour5)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute5)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second5)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond5);
                                    }
                                    DbValue::Timestamp(e) => {
                                        *base.add(0).cast::<u8>() = (16i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date6,
                                            time: time6,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year7,
                                            month: month7,
                                            day: day7,
                                        } = date6;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year7);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month7)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day7)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour8,
                                            minute: minute8,
                                            second: second8,
                                            nanosecond: nanosecond8,
                                        } = time6;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour8)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute8)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second8)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond8);
                                    }
                                    DbValue::Time(e) => {
                                        *base.add(0).cast::<u8>() = (17i32) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour9,
                                            minute: minute9,
                                            second: second9,
                                            nanosecond: nanosecond9,
                                        } = e;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(hour9)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(minute9)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(second9)) as u8;
                                        *base.add(12).cast::<i32>() = _rt::as_i32(nanosecond9);
                                    }
                                    DbValue::Year(e) => {
                                        *base.add(0).cast::<u8>() = (18i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::Fixchar(e) => {
                                        *base.add(0).cast::<u8>() = (19i32) as u8;
                                        let vec10 = e;
                                        let ptr10 = vec10.as_ptr().cast::<u8>();
                                        let len10 = vec10.len();
                                        *base.add(12).cast::<usize>() = len10;
                                        *base.add(8).cast::<*mut u8>() = ptr10.cast_mut();
                                    }
                                    DbValue::Varchar(e) => {
                                        *base.add(0).cast::<u8>() = (20i32) as u8;
                                        let vec11 = e;
                                        let ptr11 = vec11.as_ptr().cast::<u8>();
                                        let len11 = vec11.len();
                                        *base.add(12).cast::<usize>() = len11;
                                        *base.add(8).cast::<*mut u8>() = ptr11.cast_mut();
                                    }
                                    DbValue::Tinytext(e) => {
                                        *base.add(0).cast::<u8>() = (21i32) as u8;
                                        let vec12 = e;
                                        let ptr12 = vec12.as_ptr().cast::<u8>();
                                        let len12 = vec12.len();
                                        *base.add(12).cast::<usize>() = len12;
                                        *base.add(8).cast::<*mut u8>() = ptr12.cast_mut();
                                    }
                                    DbValue::Text(e) => {
                                        *base.add(0).cast::<u8>() = (22i32) as u8;
                                        let vec13 = e;
                                        let ptr13 = vec13.as_ptr().cast::<u8>();
                                        let len13 = vec13.len();
                                        *base.add(12).cast::<usize>() = len13;
                                        *base.add(8).cast::<*mut u8>() = ptr13.cast_mut();
                                    }
                                    DbValue::Mediumtext(e) => {
                                        *base.add(0).cast::<u8>() = (23i32) as u8;
                                        let vec14 = e;
                                        let ptr14 = vec14.as_ptr().cast::<u8>();
                                        let len14 = vec14.len();
                                        *base.add(12).cast::<usize>() = len14;
                                        *base.add(8).cast::<*mut u8>() = ptr14.cast_mut();
                                    }
                                    DbValue::Longtext(e) => {
                                        *base.add(0).cast::<u8>() = (24i32) as u8;
                                        let vec15 = e;
                                        let ptr15 = vec15.as_ptr().cast::<u8>();
                                        let len15 = vec15.len();
                                        *base.add(12).cast::<usize>() = len15;
                                        *base.add(8).cast::<*mut u8>() = ptr15.cast_mut();
                                    }
                                    DbValue::Binary(e) => {
                                        *base.add(0).cast::<u8>() = (25i32) as u8;
                                        let vec16 = e;
                                        let ptr16 = vec16.as_ptr().cast::<u8>();
                                        let len16 = vec16.len();
                                        *base.add(12).cast::<usize>() = len16;
                                        *base.add(8).cast::<*mut u8>() = ptr16.cast_mut();
                                    }
                                    DbValue::Varbinary(e) => {
                                        *base.add(0).cast::<u8>() = (26i32) as u8;
                                        let vec17 = e;
                                        let ptr17 = vec17.as_ptr().cast::<u8>();
                                        let len17 = vec17.len();
                                        *base.add(12).cast::<usize>() = len17;
                                        *base.add(8).cast::<*mut u8>() = ptr17.cast_mut();
                                    }
                                    DbValue::Tinyblob(e) => {
                                        *base.add(0).cast::<u8>() = (27i32) as u8;
                                        let vec18 = e;
                                        let ptr18 = vec18.as_ptr().cast::<u8>();
                                        let len18 = vec18.len();
                                        *base.add(12).cast::<usize>() = len18;
                                        *base.add(8).cast::<*mut u8>() = ptr18.cast_mut();
                                    }
                                    DbValue::Blob(e) => {
                                        *base.add(0).cast::<u8>() = (28i32) as u8;
                                        let vec19 = e;
                                        let ptr19 = vec19.as_ptr().cast::<u8>();
                                        let len19 = vec19.len();
                                        *base.add(12).cast::<usize>() = len19;
                                        *base.add(8).cast::<*mut u8>() = ptr19.cast_mut();
                                    }
                                    DbValue::Mediumblob(e) => {
                                        *base.add(0).cast::<u8>() = (29i32) as u8;
                                        let vec20 = e;
                                        let ptr20 = vec20.as_ptr().cast::<u8>();
                                        let len20 = vec20.len();
                                        *base.add(12).cast::<usize>() = len20;
                                        *base.add(8).cast::<*mut u8>() = ptr20.cast_mut();
                                    }
                                    DbValue::Longblob(e) => {
                                        *base.add(0).cast::<u8>() = (30i32) as u8;
                                        let vec21 = e;
                                        let ptr21 = vec21.as_ptr().cast::<u8>();
                                        let len21 = vec21.len();
                                        *base.add(12).cast::<usize>() = len21;
                                        *base.add(8).cast::<*mut u8>() = ptr21.cast_mut();
                                    }
                                    DbValue::Enumeration(e) => {
                                        *base.add(0).cast::<u8>() = (31i32) as u8;
                                        let vec22 = e;
                                        let ptr22 = vec22.as_ptr().cast::<u8>();
                                        let len22 = vec22.len();
                                        *base.add(12).cast::<usize>() = len22;
                                        *base.add(8).cast::<*mut u8>() = ptr22.cast_mut();
                                    }
                                    DbValue::Set(e) => {
                                        *base.add(0).cast::<u8>() = (32i32) as u8;
                                        let vec23 = e;
                                        let ptr23 = vec23.as_ptr().cast::<u8>();
                                        let len23 = vec23.len();
                                        *base.add(12).cast::<usize>() = len23;
                                        *base.add(8).cast::<*mut u8>() = ptr23.cast_mut();
                                    }
                                    DbValue::Bit(e) => {
                                        *base.add(0).cast::<u8>() = (33i32) as u8;
                                        let vec24 = e;
                                        let len24 = vec24.len();
                                        let layout24 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec24.len() * 1,
                                            1,
                                        );
                                        let result24 = if layout24.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout24).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout24);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec24.into_iter().enumerate() {
                                            let base = result24.add(i * 1);
                                            {
                                                *base.add(0).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len24;
                                        *base.add(8).cast::<*mut u8>() = result24;
                                        cleanup_list.extend_from_slice(&[(result24, layout24)]);
                                    }
                                    DbValue::Json(e) => {
                                        *base.add(0).cast::<u8>() = (34i32) as u8;
                                        let vec25 = e;
                                        let ptr25 = vec25.as_ptr().cast::<u8>();
                                        let len25 = vec25.len();
                                        *base.add(12).cast::<usize>() = len25;
                                        *base.add(8).cast::<*mut u8>() = ptr25.cast_mut();
                                    }
                                    DbValue::Null => {
                                        *base.add(0).cast::<u8>() = (35i32) as u8;
                                    }
                                }
                            }
                        }
                        let ptr27 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rdbms/mysql@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-transaction.query-stream"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            result26,
                            len26,
                            ptr27,
                        );
                        let l28 = i32::from(*ptr27.add(0).cast::<u8>());
                        if layout26.size() != 0 {
                            _rt::alloc::dealloc(result26.cast(), layout26);
                        }
                        for (ptr, layout) in cleanup_list {
                            if layout.size() != 0 {
                                _rt::alloc::dealloc(ptr.cast(), layout);
                            }
                        }
                        match l28 {
                            0 => {
                                let e = {
                                    let l29 = *ptr27.add(4).cast::<i32>();
                                    DbResultStream::from_handle(l29 as u32)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l30 = i32::from(*ptr27.add(4).cast::<u8>());
                                    let v46 = match l30 {
                                        0 => {
                                            let e46 = {
                                                let l31 = *ptr27.add(8).cast::<*mut u8>();
                                                let l32 = *ptr27.add(12).cast::<usize>();
                                                let len33 = l32;
                                                let bytes33 = _rt::Vec::from_raw_parts(
                                                    l31.cast(),
                                                    len33,
                                                    len33,
                                                );
                                                _rt::string_lift(bytes33)
                                            };
                                            Error::ConnectionFailure(e46)
                                        }
                                        1 => {
                                            let e46 = {
                                                let l34 = *ptr27.add(8).cast::<*mut u8>();
                                                let l35 = *ptr27.add(12).cast::<usize>();
                                                let len36 = l35;
                                                let bytes36 = _rt::Vec::from_raw_parts(
                                                    l34.cast(),
                                                    len36,
                                                    len36,
                                                );
                                                _rt::string_lift(bytes36)
                                            };
                                            Error::QueryParameterFailure(e46)
                                        }
                                        2 => {
                                            let e46 = {
                                                let l37 = *ptr27.add(8).cast::<*mut u8>();
                                                let l38 = *ptr27.add(12).cast::<usize>();
                                                let len39 = l38;
                                                let bytes39 = _rt::Vec::from_raw_parts(
                                                    l37.cast(),
                                                    len39,
                                                    len39,
                                                );
                                                _rt::string_lift(bytes39)
                                            };
                                            Error::QueryExecutionFailure(e46)
                                        }
                                        3 => {
                                            let e46 = {
                                                let l40 = *ptr27.add(8).cast::<*mut u8>();
                                                let l41 = *ptr27.add(12).cast::<usize>();
                                                let len42 = l41;
                                                let bytes42 = _rt::Vec::from_raw_parts(
                                                    l40.cast(),
                                                    len42,
                                                    len42,
                                                );
                                                _rt::string_lift(bytes42)
                                            };
                                            Error::QueryResponseFailure(e46)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 4, "invalid enum discriminant");
                                            let e46 = {
                                                let l43 = *ptr27.add(8).cast::<*mut u8>();
                                                let l44 = *ptr27.add(12).cast::<usize>();
                                                let len45 = l44;
                                                let bytes45 = _rt::Vec::from_raw_parts(
                                                    l43.cast(),
                                                    len45,
                                                    len45,
                                                );
                                                _rt::string_lift(bytes45)
                                            };
                                            Error::Other(e46)
                                        }
                                    };
                                    v46
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl DbTransaction {
                #[allow(unused_unsafe, clippy::all)]
                pub fn execute(
                    &self,
                    statement: &str,
                    params: &[DbValue],
                ) -> Result<u64, Error> {
                    unsafe {
                        let mut cleanup_list = _rt::Vec::new();
                        #[repr(align(8))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 24]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 24],
                        );
                        let vec0 = statement;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let vec26 = params;
                        let len26 = vec26.len();
                        let layout26 = _rt::alloc::Layout::from_size_align_unchecked(
                            vec26.len() * 24,
                            8,
                        );
                        let result26 = if layout26.size() != 0 {
                            let ptr = _rt::alloc::alloc(layout26).cast::<u8>();
                            if ptr.is_null() {
                                _rt::alloc::handle_alloc_error(layout26);
                            }
                            ptr
                        } else {
                            ::core::ptr::null_mut()
                        };
                        for (i, e) in vec26.into_iter().enumerate() {
                            let base = result26.add(i * 24);
                            {
                                match e {
                                    DbValue::Boolean(e) => {
                                        *base.add(0).cast::<u8>() = (0i32) as u8;
                                        *base.add(8).cast::<u8>() = (match e {
                                            true => 1,
                                            false => 0,
                                        }) as u8;
                                    }
                                    DbValue::Tinyint(e) => {
                                        *base.add(0).cast::<u8>() = (1i32) as u8;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                    }
                                    DbValue::Smallint(e) => {
                                        *base.add(0).cast::<u8>() = (2i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::Mediumint(e) => {
                                        *base.add(0).cast::<u8>() = (3i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Int(e) => {
                                        *base.add(0).cast::<u8>() = (4i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Bigint(e) => {
                                        *base.add(0).cast::<u8>() = (5i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::TinyintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (6i32) as u8;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                    }
                                    DbValue::SmallintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (7i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::MediumintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (8i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::IntUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (9i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::BigintUnsigned(e) => {
                                        *base.add(0).cast::<u8>() = (10i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::Float(e) => {
                                        *base.add(0).cast::<u8>() = (11i32) as u8;
                                        *base.add(8).cast::<f32>() = _rt::as_f32(e);
                                    }
                                    DbValue::Double(e) => {
                                        *base.add(0).cast::<u8>() = (12i32) as u8;
                                        *base.add(8).cast::<f64>() = _rt::as_f64(e);
                                    }
                                    DbValue::Decimal(e) => {
                                        *base.add(0).cast::<u8>() = (13i32) as u8;
                                        let vec1 = e;
                                        let ptr1 = vec1.as_ptr().cast::<u8>();
                                        let len1 = vec1.len();
                                        *base.add(12).cast::<usize>() = len1;
                                        *base.add(8).cast::<*mut u8>() = ptr1.cast_mut();
                                    }
                                    DbValue::Date(e) => {
                                        *base.add(0).cast::<u8>() = (14i32) as u8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year2,
                                            month: month2,
                                            day: day2,
                                        } = e;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year2);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month2)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day2)) as u8;
                                    }
                                    DbValue::Datetime(e) => {
                                        *base.add(0).cast::<u8>() = (15i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date3,
                                            time: time3,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year4,
                                            month: month4,
                                            day: day4,
                                        } = date3;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year4);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month4)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day4)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour5,
                                            minute: minute5,
                                            second: second5,
                                            nanosecond: nanosecond5,
                                        } = time3;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour5)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute5)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second5)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond5);
                                    }
                                    DbValue::Timestamp(e) => {
                                        *base.add(0).cast::<u8>() = (16i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date6,
                                            time: time6,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year7,
                                            month: month7,
                                            day: day7,
                                        } = date6;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year7);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month7)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day7)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour8,
                                            minute: minute8,
                                            second: second8,
                                            nanosecond: nanosecond8,
                                        } = time6;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour8)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute8)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second8)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond8);
                                    }
                                    DbValue::Time(e) => {
                                        *base.add(0).cast::<u8>() = (17i32) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour9,
                                            minute: minute9,
                                            second: second9,
                                            nanosecond: nanosecond9,
                                        } = e;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(hour9)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(minute9)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(second9)) as u8;
                                        *base.add(12).cast::<i32>() = _rt::as_i32(nanosecond9);
                                    }
                                    DbValue::Year(e) => {
                                        *base.add(0).cast::<u8>() = (18i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::Fixchar(e) => {
                                        *base.add(0).cast::<u8>() = (19i32) as u8;
                                        let vec10 = e;
                                        let ptr10 = vec10.as_ptr().cast::<u8>();
                                        let len10 = vec10.len();
                                        *base.add(12).cast::<usize>() = len10;
                                        *base.add(8).cast::<*mut u8>() = ptr10.cast_mut();
                                    }
                                    DbValue::Varchar(e) => {
                                        *base.add(0).cast::<u8>() = (20i32) as u8;
                                        let vec11 = e;
                                        let ptr11 = vec11.as_ptr().cast::<u8>();
                                        let len11 = vec11.len();
                                        *base.add(12).cast::<usize>() = len11;
                                        *base.add(8).cast::<*mut u8>() = ptr11.cast_mut();
                                    }
                                    DbValue::Tinytext(e) => {
                                        *base.add(0).cast::<u8>() = (21i32) as u8;
                                        let vec12 = e;
                                        let ptr12 = vec12.as_ptr().cast::<u8>();
                                        let len12 = vec12.len();
                                        *base.add(12).cast::<usize>() = len12;
                                        *base.add(8).cast::<*mut u8>() = ptr12.cast_mut();
                                    }
                                    DbValue::Text(e) => {
                                        *base.add(0).cast::<u8>() = (22i32) as u8;
                                        let vec13 = e;
                                        let ptr13 = vec13.as_ptr().cast::<u8>();
                                        let len13 = vec13.len();
                                        *base.add(12).cast::<usize>() = len13;
                                        *base.add(8).cast::<*mut u8>() = ptr13.cast_mut();
                                    }
                                    DbValue::Mediumtext(e) => {
                                        *base.add(0).cast::<u8>() = (23i32) as u8;
                                        let vec14 = e;
                                        let ptr14 = vec14.as_ptr().cast::<u8>();
                                        let len14 = vec14.len();
                                        *base.add(12).cast::<usize>() = len14;
                                        *base.add(8).cast::<*mut u8>() = ptr14.cast_mut();
                                    }
                                    DbValue::Longtext(e) => {
                                        *base.add(0).cast::<u8>() = (24i32) as u8;
                                        let vec15 = e;
                                        let ptr15 = vec15.as_ptr().cast::<u8>();
                                        let len15 = vec15.len();
                                        *base.add(12).cast::<usize>() = len15;
                                        *base.add(8).cast::<*mut u8>() = ptr15.cast_mut();
                                    }
                                    DbValue::Binary(e) => {
                                        *base.add(0).cast::<u8>() = (25i32) as u8;
                                        let vec16 = e;
                                        let ptr16 = vec16.as_ptr().cast::<u8>();
                                        let len16 = vec16.len();
                                        *base.add(12).cast::<usize>() = len16;
                                        *base.add(8).cast::<*mut u8>() = ptr16.cast_mut();
                                    }
                                    DbValue::Varbinary(e) => {
                                        *base.add(0).cast::<u8>() = (26i32) as u8;
                                        let vec17 = e;
                                        let ptr17 = vec17.as_ptr().cast::<u8>();
                                        let len17 = vec17.len();
                                        *base.add(12).cast::<usize>() = len17;
                                        *base.add(8).cast::<*mut u8>() = ptr17.cast_mut();
                                    }
                                    DbValue::Tinyblob(e) => {
                                        *base.add(0).cast::<u8>() = (27i32) as u8;
                                        let vec18 = e;
                                        let ptr18 = vec18.as_ptr().cast::<u8>();
                                        let len18 = vec18.len();
                                        *base.add(12).cast::<usize>() = len18;
                                        *base.add(8).cast::<*mut u8>() = ptr18.cast_mut();
                                    }
                                    DbValue::Blob(e) => {
                                        *base.add(0).cast::<u8>() = (28i32) as u8;
                                        let vec19 = e;
                                        let ptr19 = vec19.as_ptr().cast::<u8>();
                                        let len19 = vec19.len();
                                        *base.add(12).cast::<usize>() = len19;
                                        *base.add(8).cast::<*mut u8>() = ptr19.cast_mut();
                                    }
                                    DbValue::Mediumblob(e) => {
                                        *base.add(0).cast::<u8>() = (29i32) as u8;
                                        let vec20 = e;
                                        let ptr20 = vec20.as_ptr().cast::<u8>();
                                        let len20 = vec20.len();
                                        *base.add(12).cast::<usize>() = len20;
                                        *base.add(8).cast::<*mut u8>() = ptr20.cast_mut();
                                    }
                                    DbValue::Longblob(e) => {
                                        *base.add(0).cast::<u8>() = (30i32) as u8;
                                        let vec21 = e;
                                        let ptr21 = vec21.as_ptr().cast::<u8>();
                                        let len21 = vec21.len();
                                        *base.add(12).cast::<usize>() = len21;
                                        *base.add(8).cast::<*mut u8>() = ptr21.cast_mut();
                                    }
                                    DbValue::Enumeration(e) => {
                                        *base.add(0).cast::<u8>() = (31i32) as u8;
                                        let vec22 = e;
                                        let ptr22 = vec22.as_ptr().cast::<u8>();
                                        let len22 = vec22.len();
                                        *base.add(12).cast::<usize>() = len22;
                                        *base.add(8).cast::<*mut u8>() = ptr22.cast_mut();
                                    }
                                    DbValue::Set(e) => {
                                        *base.add(0).cast::<u8>() = (32i32) as u8;
                                        let vec23 = e;
                                        let ptr23 = vec23.as_ptr().cast::<u8>();
                                        let len23 = vec23.len();
                                        *base.add(12).cast::<usize>() = len23;
                                        *base.add(8).cast::<*mut u8>() = ptr23.cast_mut();
                                    }
                                    DbValue::Bit(e) => {
                                        *base.add(0).cast::<u8>() = (33i32) as u8;
                                        let vec24 = e;
                                        let len24 = vec24.len();
                                        let layout24 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec24.len() * 1,
                                            1,
                                        );
                                        let result24 = if layout24.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout24).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout24);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec24.into_iter().enumerate() {
                                            let base = result24.add(i * 1);
                                            {
                                                *base.add(0).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len24;
                                        *base.add(8).cast::<*mut u8>() = result24;
                                        cleanup_list.extend_from_slice(&[(result24, layout24)]);
                                    }
                                    DbValue::Json(e) => {
                                        *base.add(0).cast::<u8>() = (34i32) as u8;
                                        let vec25 = e;
                                        let ptr25 = vec25.as_ptr().cast::<u8>();
                                        let len25 = vec25.len();
                                        *base.add(12).cast::<usize>() = len25;
                                        *base.add(8).cast::<*mut u8>() = ptr25.cast_mut();
                                    }
                                    DbValue::Null => {
                                        *base.add(0).cast::<u8>() = (35i32) as u8;
                                    }
                                }
                            }
                        }
                        let ptr27 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rdbms/mysql@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-transaction.execute"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            result26,
                            len26,
                            ptr27,
                        );
                        let l28 = i32::from(*ptr27.add(0).cast::<u8>());
                        if layout26.size() != 0 {
                            _rt::alloc::dealloc(result26.cast(), layout26);
                        }
                        for (ptr, layout) in cleanup_list {
                            if layout.size() != 0 {
                                _rt::alloc::dealloc(ptr.cast(), layout);
                            }
                        }
                        match l28 {
                            0 => {
                                let e = {
                                    let l29 = *ptr27.add(8).cast::<i64>();
                                    l29 as u64
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l30 = i32::from(*ptr27.add(8).cast::<u8>());
                                    let v46 = match l30 {
                                        0 => {
                                            let e46 = {
                                                let l31 = *ptr27.add(12).cast::<*mut u8>();
                                                let l32 = *ptr27.add(16).cast::<usize>();
                                                let len33 = l32;
                                                let bytes33 = _rt::Vec::from_raw_parts(
                                                    l31.cast(),
                                                    len33,
                                                    len33,
                                                );
                                                _rt::string_lift(bytes33)
                                            };
                                            Error::ConnectionFailure(e46)
                                        }
                                        1 => {
                                            let e46 = {
                                                let l34 = *ptr27.add(12).cast::<*mut u8>();
                                                let l35 = *ptr27.add(16).cast::<usize>();
                                                let len36 = l35;
                                                let bytes36 = _rt::Vec::from_raw_parts(
                                                    l34.cast(),
                                                    len36,
                                                    len36,
                                                );
                                                _rt::string_lift(bytes36)
                                            };
                                            Error::QueryParameterFailure(e46)
                                        }
                                        2 => {
                                            let e46 = {
                                                let l37 = *ptr27.add(12).cast::<*mut u8>();
                                                let l38 = *ptr27.add(16).cast::<usize>();
                                                let len39 = l38;
                                                let bytes39 = _rt::Vec::from_raw_parts(
                                                    l37.cast(),
                                                    len39,
                                                    len39,
                                                );
                                                _rt::string_lift(bytes39)
                                            };
                                            Error::QueryExecutionFailure(e46)
                                        }
                                        3 => {
                                            let e46 = {
                                                let l40 = *ptr27.add(12).cast::<*mut u8>();
                                                let l41 = *ptr27.add(16).cast::<usize>();
                                                let len42 = l41;
                                                let bytes42 = _rt::Vec::from_raw_parts(
                                                    l40.cast(),
                                                    len42,
                                                    len42,
                                                );
                                                _rt::string_lift(bytes42)
                                            };
                                            Error::QueryResponseFailure(e46)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 4, "invalid enum discriminant");
                                            let e46 = {
                                                let l43 = *ptr27.add(12).cast::<*mut u8>();
                                                let l44 = *ptr27.add(16).cast::<usize>();
                                                let len45 = l44;
                                                let bytes45 = _rt::Vec::from_raw_parts(
                                                    l43.cast(),
                                                    len45,
                                                    len45,
                                                );
                                                _rt::string_lift(bytes45)
                                            };
                                            Error::Other(e46)
                                        }
                                    };
                                    v46
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl DbTransaction {
                #[allow(unused_unsafe, clippy::all)]
                pub fn commit(&self) -> Result<(), Error> {
                    unsafe {
                        #[repr(align(4))]
                        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 = "golem:rdbms/mysql@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-transaction.commit"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(4).cast::<u8>());
                                    let v18 = match l2 {
                                        0 => {
                                            let e18 = {
                                                let l3 = *ptr0.add(8).cast::<*mut u8>();
                                                let l4 = *ptr0.add(12).cast::<usize>();
                                                let len5 = l4;
                                                let bytes5 = _rt::Vec::from_raw_parts(
                                                    l3.cast(),
                                                    len5,
                                                    len5,
                                                );
                                                _rt::string_lift(bytes5)
                                            };
                                            Error::ConnectionFailure(e18)
                                        }
                                        1 => {
                                            let e18 = {
                                                let l6 = *ptr0.add(8).cast::<*mut u8>();
                                                let l7 = *ptr0.add(12).cast::<usize>();
                                                let len8 = l7;
                                                let bytes8 = _rt::Vec::from_raw_parts(
                                                    l6.cast(),
                                                    len8,
                                                    len8,
                                                );
                                                _rt::string_lift(bytes8)
                                            };
                                            Error::QueryParameterFailure(e18)
                                        }
                                        2 => {
                                            let e18 = {
                                                let l9 = *ptr0.add(8).cast::<*mut u8>();
                                                let l10 = *ptr0.add(12).cast::<usize>();
                                                let len11 = l10;
                                                let bytes11 = _rt::Vec::from_raw_parts(
                                                    l9.cast(),
                                                    len11,
                                                    len11,
                                                );
                                                _rt::string_lift(bytes11)
                                            };
                                            Error::QueryExecutionFailure(e18)
                                        }
                                        3 => {
                                            let e18 = {
                                                let l12 = *ptr0.add(8).cast::<*mut u8>();
                                                let l13 = *ptr0.add(12).cast::<usize>();
                                                let len14 = l13;
                                                let bytes14 = _rt::Vec::from_raw_parts(
                                                    l12.cast(),
                                                    len14,
                                                    len14,
                                                );
                                                _rt::string_lift(bytes14)
                                            };
                                            Error::QueryResponseFailure(e18)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 4, "invalid enum discriminant");
                                            let e18 = {
                                                let l15 = *ptr0.add(8).cast::<*mut u8>();
                                                let l16 = *ptr0.add(12).cast::<usize>();
                                                let len17 = l16;
                                                let bytes17 = _rt::Vec::from_raw_parts(
                                                    l15.cast(),
                                                    len17,
                                                    len17,
                                                );
                                                _rt::string_lift(bytes17)
                                            };
                                            Error::Other(e18)
                                        }
                                    };
                                    v18
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl DbTransaction {
                #[allow(unused_unsafe, clippy::all)]
                pub fn rollback(&self) -> Result<(), Error> {
                    unsafe {
                        #[repr(align(4))]
                        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 = "golem:rdbms/mysql@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-transaction.rollback"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(4).cast::<u8>());
                                    let v18 = match l2 {
                                        0 => {
                                            let e18 = {
                                                let l3 = *ptr0.add(8).cast::<*mut u8>();
                                                let l4 = *ptr0.add(12).cast::<usize>();
                                                let len5 = l4;
                                                let bytes5 = _rt::Vec::from_raw_parts(
                                                    l3.cast(),
                                                    len5,
                                                    len5,
                                                );
                                                _rt::string_lift(bytes5)
                                            };
                                            Error::ConnectionFailure(e18)
                                        }
                                        1 => {
                                            let e18 = {
                                                let l6 = *ptr0.add(8).cast::<*mut u8>();
                                                let l7 = *ptr0.add(12).cast::<usize>();
                                                let len8 = l7;
                                                let bytes8 = _rt::Vec::from_raw_parts(
                                                    l6.cast(),
                                                    len8,
                                                    len8,
                                                );
                                                _rt::string_lift(bytes8)
                                            };
                                            Error::QueryParameterFailure(e18)
                                        }
                                        2 => {
                                            let e18 = {
                                                let l9 = *ptr0.add(8).cast::<*mut u8>();
                                                let l10 = *ptr0.add(12).cast::<usize>();
                                                let len11 = l10;
                                                let bytes11 = _rt::Vec::from_raw_parts(
                                                    l9.cast(),
                                                    len11,
                                                    len11,
                                                );
                                                _rt::string_lift(bytes11)
                                            };
                                            Error::QueryExecutionFailure(e18)
                                        }
                                        3 => {
                                            let e18 = {
                                                let l12 = *ptr0.add(8).cast::<*mut u8>();
                                                let l13 = *ptr0.add(12).cast::<usize>();
                                                let len14 = l13;
                                                let bytes14 = _rt::Vec::from_raw_parts(
                                                    l12.cast(),
                                                    len14,
                                                    len14,
                                                );
                                                _rt::string_lift(bytes14)
                                            };
                                            Error::QueryResponseFailure(e18)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 4, "invalid enum discriminant");
                                            let e18 = {
                                                let l15 = *ptr0.add(8).cast::<*mut u8>();
                                                let l16 = *ptr0.add(12).cast::<usize>();
                                                let len17 = l16;
                                                let bytes17 = _rt::Vec::from_raw_parts(
                                                    l15.cast(),
                                                    len17,
                                                    len17,
                                                );
                                                _rt::string_lift(bytes17)
                                            };
                                            Error::Other(e18)
                                        }
                                    };
                                    v18
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
        }
        #[allow(dead_code, clippy::all)]
        pub mod postgres {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            use super::super::super::_rt;
            pub type Date = super::super::super::golem::rdbms::types::Date;
            pub type Time = super::super::super::golem::rdbms::types::Time;
            pub type Timetz = super::super::super::golem::rdbms::types::Timetz;
            pub type Timestamp = super::super::super::golem::rdbms::types::Timestamp;
            pub type Timestamptz = super::super::super::golem::rdbms::types::Timestamptz;
            pub type Uuid = super::super::super::golem::rdbms::types::Uuid;
            pub type IpAddress = super::super::super::golem::rdbms::types::IpAddress;
            pub type MacAddress = super::super::super::golem::rdbms::types::MacAddress;
            #[derive(Clone)]
            pub enum Error {
                ConnectionFailure(_rt::String),
                QueryParameterFailure(_rt::String),
                QueryExecutionFailure(_rt::String),
                QueryResponseFailure(_rt::String),
                Other(_rt::String),
            }
            impl ::core::fmt::Debug for Error {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        Error::ConnectionFailure(e) => {
                            f.debug_tuple("Error::ConnectionFailure").field(e).finish()
                        }
                        Error::QueryParameterFailure(e) => {
                            f.debug_tuple("Error::QueryParameterFailure")
                                .field(e)
                                .finish()
                        }
                        Error::QueryExecutionFailure(e) => {
                            f.debug_tuple("Error::QueryExecutionFailure")
                                .field(e)
                                .finish()
                        }
                        Error::QueryResponseFailure(e) => {
                            f.debug_tuple("Error::QueryResponseFailure")
                                .field(e)
                                .finish()
                        }
                        Error::Other(e) => {
                            f.debug_tuple("Error::Other").field(e).finish()
                        }
                    }
                }
            }
            impl ::core::fmt::Display for Error {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    write!(f, "{:?}", self)
                }
            }
            impl std::error::Error for Error {}
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct Interval {
                pub months: i32,
                pub days: i32,
                pub microseconds: i64,
            }
            impl ::core::fmt::Debug for Interval {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Interval")
                        .field("months", &self.months)
                        .field("days", &self.days)
                        .field("microseconds", &self.microseconds)
                        .finish()
                }
            }
            #[derive(Clone, Copy)]
            pub enum Int4bound {
                Included(i32),
                Excluded(i32),
                Unbounded,
            }
            impl ::core::fmt::Debug for Int4bound {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        Int4bound::Included(e) => {
                            f.debug_tuple("Int4bound::Included").field(e).finish()
                        }
                        Int4bound::Excluded(e) => {
                            f.debug_tuple("Int4bound::Excluded").field(e).finish()
                        }
                        Int4bound::Unbounded => {
                            f.debug_tuple("Int4bound::Unbounded").finish()
                        }
                    }
                }
            }
            #[derive(Clone, Copy)]
            pub enum Int8bound {
                Included(i64),
                Excluded(i64),
                Unbounded,
            }
            impl ::core::fmt::Debug for Int8bound {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        Int8bound::Included(e) => {
                            f.debug_tuple("Int8bound::Included").field(e).finish()
                        }
                        Int8bound::Excluded(e) => {
                            f.debug_tuple("Int8bound::Excluded").field(e).finish()
                        }
                        Int8bound::Unbounded => {
                            f.debug_tuple("Int8bound::Unbounded").finish()
                        }
                    }
                }
            }
            #[derive(Clone)]
            pub enum Numbound {
                Included(_rt::String),
                Excluded(_rt::String),
                Unbounded,
            }
            impl ::core::fmt::Debug for Numbound {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        Numbound::Included(e) => {
                            f.debug_tuple("Numbound::Included").field(e).finish()
                        }
                        Numbound::Excluded(e) => {
                            f.debug_tuple("Numbound::Excluded").field(e).finish()
                        }
                        Numbound::Unbounded => {
                            f.debug_tuple("Numbound::Unbounded").finish()
                        }
                    }
                }
            }
            #[derive(Clone, Copy)]
            pub enum Tsbound {
                Included(Timestamp),
                Excluded(Timestamp),
                Unbounded,
            }
            impl ::core::fmt::Debug for Tsbound {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        Tsbound::Included(e) => {
                            f.debug_tuple("Tsbound::Included").field(e).finish()
                        }
                        Tsbound::Excluded(e) => {
                            f.debug_tuple("Tsbound::Excluded").field(e).finish()
                        }
                        Tsbound::Unbounded => {
                            f.debug_tuple("Tsbound::Unbounded").finish()
                        }
                    }
                }
            }
            #[derive(Clone, Copy)]
            pub enum Tstzbound {
                Included(Timestamptz),
                Excluded(Timestamptz),
                Unbounded,
            }
            impl ::core::fmt::Debug for Tstzbound {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        Tstzbound::Included(e) => {
                            f.debug_tuple("Tstzbound::Included").field(e).finish()
                        }
                        Tstzbound::Excluded(e) => {
                            f.debug_tuple("Tstzbound::Excluded").field(e).finish()
                        }
                        Tstzbound::Unbounded => {
                            f.debug_tuple("Tstzbound::Unbounded").finish()
                        }
                    }
                }
            }
            #[derive(Clone, Copy)]
            pub enum Datebound {
                Included(Date),
                Excluded(Date),
                Unbounded,
            }
            impl ::core::fmt::Debug for Datebound {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        Datebound::Included(e) => {
                            f.debug_tuple("Datebound::Included").field(e).finish()
                        }
                        Datebound::Excluded(e) => {
                            f.debug_tuple("Datebound::Excluded").field(e).finish()
                        }
                        Datebound::Unbounded => {
                            f.debug_tuple("Datebound::Unbounded").finish()
                        }
                    }
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct Int4range {
                pub start: Int4bound,
                pub end: Int4bound,
            }
            impl ::core::fmt::Debug for Int4range {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Int4range")
                        .field("start", &self.start)
                        .field("end", &self.end)
                        .finish()
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct Int8range {
                pub start: Int8bound,
                pub end: Int8bound,
            }
            impl ::core::fmt::Debug for Int8range {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Int8range")
                        .field("start", &self.start)
                        .field("end", &self.end)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub struct Numrange {
                pub start: Numbound,
                pub end: Numbound,
            }
            impl ::core::fmt::Debug for Numrange {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Numrange")
                        .field("start", &self.start)
                        .field("end", &self.end)
                        .finish()
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct Tsrange {
                pub start: Tsbound,
                pub end: Tsbound,
            }
            impl ::core::fmt::Debug for Tsrange {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Tsrange")
                        .field("start", &self.start)
                        .field("end", &self.end)
                        .finish()
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct Tstzrange {
                pub start: Tstzbound,
                pub end: Tstzbound,
            }
            impl ::core::fmt::Debug for Tstzrange {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Tstzrange")
                        .field("start", &self.start)
                        .field("end", &self.end)
                        .finish()
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct Daterange {
                pub start: Datebound,
                pub end: Datebound,
            }
            impl ::core::fmt::Debug for Daterange {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Daterange")
                        .field("start", &self.start)
                        .field("end", &self.end)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub struct EnumerationType {
                pub name: _rt::String,
            }
            impl ::core::fmt::Debug for EnumerationType {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("EnumerationType").field("name", &self.name).finish()
                }
            }
            #[derive(Clone)]
            pub struct Enumeration {
                pub name: _rt::String,
                pub value: _rt::String,
            }
            impl ::core::fmt::Debug for Enumeration {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Enumeration")
                        .field("name", &self.name)
                        .field("value", &self.value)
                        .finish()
                }
            }
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct LazyDbValue {
                handle: _rt::Resource<LazyDbValue>,
            }
            impl LazyDbValue {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 LazyDbValue {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "golem:rdbms/postgres@0.0.1")]
                        extern "C" {
                            #[link_name = "[resource-drop]lazy-db-value"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            pub struct Composite {
                pub name: _rt::String,
                pub values: _rt::Vec<LazyDbValue>,
            }
            impl ::core::fmt::Debug for Composite {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Composite")
                        .field("name", &self.name)
                        .field("values", &self.values)
                        .finish()
                }
            }
            pub struct Domain {
                pub name: _rt::String,
                pub value: LazyDbValue,
            }
            impl ::core::fmt::Debug for Domain {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Domain")
                        .field("name", &self.name)
                        .field("value", &self.value)
                        .finish()
                }
            }
            pub enum ValueBound {
                Included(LazyDbValue),
                Excluded(LazyDbValue),
                Unbounded,
            }
            impl ::core::fmt::Debug for ValueBound {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        ValueBound::Included(e) => {
                            f.debug_tuple("ValueBound::Included").field(e).finish()
                        }
                        ValueBound::Excluded(e) => {
                            f.debug_tuple("ValueBound::Excluded").field(e).finish()
                        }
                        ValueBound::Unbounded => {
                            f.debug_tuple("ValueBound::Unbounded").finish()
                        }
                    }
                }
            }
            pub struct ValuesRange {
                pub start: ValueBound,
                pub end: ValueBound,
            }
            impl ::core::fmt::Debug for ValuesRange {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("ValuesRange")
                        .field("start", &self.start)
                        .field("end", &self.end)
                        .finish()
                }
            }
            pub struct Range {
                pub name: _rt::String,
                pub value: ValuesRange,
            }
            impl ::core::fmt::Debug for Range {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Range")
                        .field("name", &self.name)
                        .field("value", &self.value)
                        .finish()
                }
            }
            pub enum DbValue {
                Character(i8),
                Int2(i16),
                Int4(i32),
                Int8(i64),
                Float4(f32),
                Float8(f64),
                Numeric(_rt::String),
                Boolean(bool),
                Text(_rt::String),
                Varchar(_rt::String),
                Bpchar(_rt::String),
                Timestamp(Timestamp),
                Timestamptz(Timestamptz),
                Date(Date),
                Time(Time),
                Timetz(Timetz),
                Interval(Interval),
                Bytea(_rt::Vec<u8>),
                Json(_rt::String),
                Jsonb(_rt::String),
                Jsonpath(_rt::String),
                Xml(_rt::String),
                Uuid(Uuid),
                Inet(IpAddress),
                Cidr(IpAddress),
                Macaddr(MacAddress),
                Bit(_rt::Vec<bool>),
                Varbit(_rt::Vec<bool>),
                Int4range(Int4range),
                Int8range(Int8range),
                Numrange(Numrange),
                Tsrange(Tsrange),
                Tstzrange(Tstzrange),
                Daterange(Daterange),
                Money(i64),
                Oid(u32),
                Enumeration(Enumeration),
                Composite(Composite),
                Domain(Domain),
                Array(_rt::Vec<LazyDbValue>),
                Range(Range),
                Null,
            }
            impl ::core::fmt::Debug for DbValue {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        DbValue::Character(e) => {
                            f.debug_tuple("DbValue::Character").field(e).finish()
                        }
                        DbValue::Int2(e) => {
                            f.debug_tuple("DbValue::Int2").field(e).finish()
                        }
                        DbValue::Int4(e) => {
                            f.debug_tuple("DbValue::Int4").field(e).finish()
                        }
                        DbValue::Int8(e) => {
                            f.debug_tuple("DbValue::Int8").field(e).finish()
                        }
                        DbValue::Float4(e) => {
                            f.debug_tuple("DbValue::Float4").field(e).finish()
                        }
                        DbValue::Float8(e) => {
                            f.debug_tuple("DbValue::Float8").field(e).finish()
                        }
                        DbValue::Numeric(e) => {
                            f.debug_tuple("DbValue::Numeric").field(e).finish()
                        }
                        DbValue::Boolean(e) => {
                            f.debug_tuple("DbValue::Boolean").field(e).finish()
                        }
                        DbValue::Text(e) => {
                            f.debug_tuple("DbValue::Text").field(e).finish()
                        }
                        DbValue::Varchar(e) => {
                            f.debug_tuple("DbValue::Varchar").field(e).finish()
                        }
                        DbValue::Bpchar(e) => {
                            f.debug_tuple("DbValue::Bpchar").field(e).finish()
                        }
                        DbValue::Timestamp(e) => {
                            f.debug_tuple("DbValue::Timestamp").field(e).finish()
                        }
                        DbValue::Timestamptz(e) => {
                            f.debug_tuple("DbValue::Timestamptz").field(e).finish()
                        }
                        DbValue::Date(e) => {
                            f.debug_tuple("DbValue::Date").field(e).finish()
                        }
                        DbValue::Time(e) => {
                            f.debug_tuple("DbValue::Time").field(e).finish()
                        }
                        DbValue::Timetz(e) => {
                            f.debug_tuple("DbValue::Timetz").field(e).finish()
                        }
                        DbValue::Interval(e) => {
                            f.debug_tuple("DbValue::Interval").field(e).finish()
                        }
                        DbValue::Bytea(e) => {
                            f.debug_tuple("DbValue::Bytea").field(e).finish()
                        }
                        DbValue::Json(e) => {
                            f.debug_tuple("DbValue::Json").field(e).finish()
                        }
                        DbValue::Jsonb(e) => {
                            f.debug_tuple("DbValue::Jsonb").field(e).finish()
                        }
                        DbValue::Jsonpath(e) => {
                            f.debug_tuple("DbValue::Jsonpath").field(e).finish()
                        }
                        DbValue::Xml(e) => {
                            f.debug_tuple("DbValue::Xml").field(e).finish()
                        }
                        DbValue::Uuid(e) => {
                            f.debug_tuple("DbValue::Uuid").field(e).finish()
                        }
                        DbValue::Inet(e) => {
                            f.debug_tuple("DbValue::Inet").field(e).finish()
                        }
                        DbValue::Cidr(e) => {
                            f.debug_tuple("DbValue::Cidr").field(e).finish()
                        }
                        DbValue::Macaddr(e) => {
                            f.debug_tuple("DbValue::Macaddr").field(e).finish()
                        }
                        DbValue::Bit(e) => {
                            f.debug_tuple("DbValue::Bit").field(e).finish()
                        }
                        DbValue::Varbit(e) => {
                            f.debug_tuple("DbValue::Varbit").field(e).finish()
                        }
                        DbValue::Int4range(e) => {
                            f.debug_tuple("DbValue::Int4range").field(e).finish()
                        }
                        DbValue::Int8range(e) => {
                            f.debug_tuple("DbValue::Int8range").field(e).finish()
                        }
                        DbValue::Numrange(e) => {
                            f.debug_tuple("DbValue::Numrange").field(e).finish()
                        }
                        DbValue::Tsrange(e) => {
                            f.debug_tuple("DbValue::Tsrange").field(e).finish()
                        }
                        DbValue::Tstzrange(e) => {
                            f.debug_tuple("DbValue::Tstzrange").field(e).finish()
                        }
                        DbValue::Daterange(e) => {
                            f.debug_tuple("DbValue::Daterange").field(e).finish()
                        }
                        DbValue::Money(e) => {
                            f.debug_tuple("DbValue::Money").field(e).finish()
                        }
                        DbValue::Oid(e) => {
                            f.debug_tuple("DbValue::Oid").field(e).finish()
                        }
                        DbValue::Enumeration(e) => {
                            f.debug_tuple("DbValue::Enumeration").field(e).finish()
                        }
                        DbValue::Composite(e) => {
                            f.debug_tuple("DbValue::Composite").field(e).finish()
                        }
                        DbValue::Domain(e) => {
                            f.debug_tuple("DbValue::Domain").field(e).finish()
                        }
                        DbValue::Array(e) => {
                            f.debug_tuple("DbValue::Array").field(e).finish()
                        }
                        DbValue::Range(e) => {
                            f.debug_tuple("DbValue::Range").field(e).finish()
                        }
                        DbValue::Null => f.debug_tuple("DbValue::Null").finish(),
                    }
                }
            }
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct LazyDbColumnType {
                handle: _rt::Resource<LazyDbColumnType>,
            }
            impl LazyDbColumnType {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 LazyDbColumnType {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "golem:rdbms/postgres@0.0.1")]
                        extern "C" {
                            #[link_name = "[resource-drop]lazy-db-column-type"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            pub struct CompositeType {
                pub name: _rt::String,
                pub attributes: _rt::Vec<(_rt::String, LazyDbColumnType)>,
            }
            impl ::core::fmt::Debug for CompositeType {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("CompositeType")
                        .field("name", &self.name)
                        .field("attributes", &self.attributes)
                        .finish()
                }
            }
            pub struct DomainType {
                pub name: _rt::String,
                pub base_type: LazyDbColumnType,
            }
            impl ::core::fmt::Debug for DomainType {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("DomainType")
                        .field("name", &self.name)
                        .field("base-type", &self.base_type)
                        .finish()
                }
            }
            pub struct RangeType {
                pub name: _rt::String,
                pub base_type: LazyDbColumnType,
            }
            impl ::core::fmt::Debug for RangeType {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("RangeType")
                        .field("name", &self.name)
                        .field("base-type", &self.base_type)
                        .finish()
                }
            }
            pub enum DbColumnType {
                Character,
                Int2,
                Int4,
                Int8,
                Float4,
                Float8,
                Numeric,
                Boolean,
                Text,
                Varchar,
                Bpchar,
                Timestamp,
                Timestamptz,
                Date,
                Time,
                Timetz,
                Interval,
                Bytea,
                Uuid,
                Xml,
                Json,
                Jsonb,
                Jsonpath,
                Inet,
                Cidr,
                Macaddr,
                Bit,
                Varbit,
                Int4range,
                Int8range,
                Numrange,
                Tsrange,
                Tstzrange,
                Daterange,
                Money,
                Oid,
                Enumeration(EnumerationType),
                Composite(CompositeType),
                Domain(DomainType),
                Array(LazyDbColumnType),
                Range(RangeType),
            }
            impl ::core::fmt::Debug for DbColumnType {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        DbColumnType::Character => {
                            f.debug_tuple("DbColumnType::Character").finish()
                        }
                        DbColumnType::Int2 => {
                            f.debug_tuple("DbColumnType::Int2").finish()
                        }
                        DbColumnType::Int4 => {
                            f.debug_tuple("DbColumnType::Int4").finish()
                        }
                        DbColumnType::Int8 => {
                            f.debug_tuple("DbColumnType::Int8").finish()
                        }
                        DbColumnType::Float4 => {
                            f.debug_tuple("DbColumnType::Float4").finish()
                        }
                        DbColumnType::Float8 => {
                            f.debug_tuple("DbColumnType::Float8").finish()
                        }
                        DbColumnType::Numeric => {
                            f.debug_tuple("DbColumnType::Numeric").finish()
                        }
                        DbColumnType::Boolean => {
                            f.debug_tuple("DbColumnType::Boolean").finish()
                        }
                        DbColumnType::Text => {
                            f.debug_tuple("DbColumnType::Text").finish()
                        }
                        DbColumnType::Varchar => {
                            f.debug_tuple("DbColumnType::Varchar").finish()
                        }
                        DbColumnType::Bpchar => {
                            f.debug_tuple("DbColumnType::Bpchar").finish()
                        }
                        DbColumnType::Timestamp => {
                            f.debug_tuple("DbColumnType::Timestamp").finish()
                        }
                        DbColumnType::Timestamptz => {
                            f.debug_tuple("DbColumnType::Timestamptz").finish()
                        }
                        DbColumnType::Date => {
                            f.debug_tuple("DbColumnType::Date").finish()
                        }
                        DbColumnType::Time => {
                            f.debug_tuple("DbColumnType::Time").finish()
                        }
                        DbColumnType::Timetz => {
                            f.debug_tuple("DbColumnType::Timetz").finish()
                        }
                        DbColumnType::Interval => {
                            f.debug_tuple("DbColumnType::Interval").finish()
                        }
                        DbColumnType::Bytea => {
                            f.debug_tuple("DbColumnType::Bytea").finish()
                        }
                        DbColumnType::Uuid => {
                            f.debug_tuple("DbColumnType::Uuid").finish()
                        }
                        DbColumnType::Xml => f.debug_tuple("DbColumnType::Xml").finish(),
                        DbColumnType::Json => {
                            f.debug_tuple("DbColumnType::Json").finish()
                        }
                        DbColumnType::Jsonb => {
                            f.debug_tuple("DbColumnType::Jsonb").finish()
                        }
                        DbColumnType::Jsonpath => {
                            f.debug_tuple("DbColumnType::Jsonpath").finish()
                        }
                        DbColumnType::Inet => {
                            f.debug_tuple("DbColumnType::Inet").finish()
                        }
                        DbColumnType::Cidr => {
                            f.debug_tuple("DbColumnType::Cidr").finish()
                        }
                        DbColumnType::Macaddr => {
                            f.debug_tuple("DbColumnType::Macaddr").finish()
                        }
                        DbColumnType::Bit => f.debug_tuple("DbColumnType::Bit").finish(),
                        DbColumnType::Varbit => {
                            f.debug_tuple("DbColumnType::Varbit").finish()
                        }
                        DbColumnType::Int4range => {
                            f.debug_tuple("DbColumnType::Int4range").finish()
                        }
                        DbColumnType::Int8range => {
                            f.debug_tuple("DbColumnType::Int8range").finish()
                        }
                        DbColumnType::Numrange => {
                            f.debug_tuple("DbColumnType::Numrange").finish()
                        }
                        DbColumnType::Tsrange => {
                            f.debug_tuple("DbColumnType::Tsrange").finish()
                        }
                        DbColumnType::Tstzrange => {
                            f.debug_tuple("DbColumnType::Tstzrange").finish()
                        }
                        DbColumnType::Daterange => {
                            f.debug_tuple("DbColumnType::Daterange").finish()
                        }
                        DbColumnType::Money => {
                            f.debug_tuple("DbColumnType::Money").finish()
                        }
                        DbColumnType::Oid => f.debug_tuple("DbColumnType::Oid").finish(),
                        DbColumnType::Enumeration(e) => {
                            f.debug_tuple("DbColumnType::Enumeration").field(e).finish()
                        }
                        DbColumnType::Composite(e) => {
                            f.debug_tuple("DbColumnType::Composite").field(e).finish()
                        }
                        DbColumnType::Domain(e) => {
                            f.debug_tuple("DbColumnType::Domain").field(e).finish()
                        }
                        DbColumnType::Array(e) => {
                            f.debug_tuple("DbColumnType::Array").field(e).finish()
                        }
                        DbColumnType::Range(e) => {
                            f.debug_tuple("DbColumnType::Range").field(e).finish()
                        }
                    }
                }
            }
            pub struct DbColumn {
                pub ordinal: u64,
                pub name: _rt::String,
                pub db_type: DbColumnType,
                pub db_type_name: _rt::String,
            }
            impl ::core::fmt::Debug for DbColumn {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("DbColumn")
                        .field("ordinal", &self.ordinal)
                        .field("name", &self.name)
                        .field("db-type", &self.db_type)
                        .field("db-type-name", &self.db_type_name)
                        .finish()
                }
            }
            /// A single row of values
            pub struct DbRow {
                pub values: _rt::Vec<DbValue>,
            }
            impl ::core::fmt::Debug for DbRow {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("DbRow").field("values", &self.values).finish()
                }
            }
            pub struct DbResult {
                pub columns: _rt::Vec<DbColumn>,
                pub rows: _rt::Vec<DbRow>,
            }
            impl ::core::fmt::Debug for DbResult {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("DbResult")
                        .field("columns", &self.columns)
                        .field("rows", &self.rows)
                        .finish()
                }
            }
            /// A potentially very large and lazy stream of rows:
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct DbResultStream {
                handle: _rt::Resource<DbResultStream>,
            }
            impl DbResultStream {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 DbResultStream {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "golem:rdbms/postgres@0.0.1")]
                        extern "C" {
                            #[link_name = "[resource-drop]db-result-stream"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct DbConnection {
                handle: _rt::Resource<DbConnection>,
            }
            impl DbConnection {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 DbConnection {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "golem:rdbms/postgres@0.0.1")]
                        extern "C" {
                            #[link_name = "[resource-drop]db-connection"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct DbTransaction {
                handle: _rt::Resource<DbTransaction>,
            }
            impl DbTransaction {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 DbTransaction {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "golem:rdbms/postgres@0.0.1")]
                        extern "C" {
                            #[link_name = "[resource-drop]db-transaction"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            impl LazyDbValue {
                #[allow(unused_unsafe, clippy::all)]
                pub fn new(value: DbValue) -> Self {
                    unsafe {
                        let mut cleanup_list = _rt::Vec::new();
                        #[repr(align(8))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 56]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 56],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        match &value {
                            DbValue::Character(e) => {
                                *ptr0.add(0).cast::<u8>() = (0i32) as u8;
                                *ptr0.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                            }
                            DbValue::Int2(e) => {
                                *ptr0.add(0).cast::<u8>() = (1i32) as u8;
                                *ptr0.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                            }
                            DbValue::Int4(e) => {
                                *ptr0.add(0).cast::<u8>() = (2i32) as u8;
                                *ptr0.add(8).cast::<i32>() = _rt::as_i32(e);
                            }
                            DbValue::Int8(e) => {
                                *ptr0.add(0).cast::<u8>() = (3i32) as u8;
                                *ptr0.add(8).cast::<i64>() = _rt::as_i64(e);
                            }
                            DbValue::Float4(e) => {
                                *ptr0.add(0).cast::<u8>() = (4i32) as u8;
                                *ptr0.add(8).cast::<f32>() = _rt::as_f32(e);
                            }
                            DbValue::Float8(e) => {
                                *ptr0.add(0).cast::<u8>() = (5i32) as u8;
                                *ptr0.add(8).cast::<f64>() = _rt::as_f64(e);
                            }
                            DbValue::Numeric(e) => {
                                *ptr0.add(0).cast::<u8>() = (6i32) as u8;
                                let vec1 = e;
                                let ptr1 = vec1.as_ptr().cast::<u8>();
                                let len1 = vec1.len();
                                *ptr0.add(12).cast::<usize>() = len1;
                                *ptr0.add(8).cast::<*mut u8>() = ptr1.cast_mut();
                            }
                            DbValue::Boolean(e) => {
                                *ptr0.add(0).cast::<u8>() = (7i32) as u8;
                                *ptr0.add(8).cast::<u8>() = (match e {
                                    true => 1,
                                    false => 0,
                                }) as u8;
                            }
                            DbValue::Text(e) => {
                                *ptr0.add(0).cast::<u8>() = (8i32) as u8;
                                let vec2 = e;
                                let ptr2 = vec2.as_ptr().cast::<u8>();
                                let len2 = vec2.len();
                                *ptr0.add(12).cast::<usize>() = len2;
                                *ptr0.add(8).cast::<*mut u8>() = ptr2.cast_mut();
                            }
                            DbValue::Varchar(e) => {
                                *ptr0.add(0).cast::<u8>() = (9i32) as u8;
                                let vec3 = e;
                                let ptr3 = vec3.as_ptr().cast::<u8>();
                                let len3 = vec3.len();
                                *ptr0.add(12).cast::<usize>() = len3;
                                *ptr0.add(8).cast::<*mut u8>() = ptr3.cast_mut();
                            }
                            DbValue::Bpchar(e) => {
                                *ptr0.add(0).cast::<u8>() = (10i32) as u8;
                                let vec4 = e;
                                let ptr4 = vec4.as_ptr().cast::<u8>();
                                let len4 = vec4.len();
                                *ptr0.add(12).cast::<usize>() = len4;
                                *ptr0.add(8).cast::<*mut u8>() = ptr4.cast_mut();
                            }
                            DbValue::Timestamp(e) => {
                                *ptr0.add(0).cast::<u8>() = (11i32) as u8;
                                let super::super::super::golem::rdbms::types::Timestamp {
                                    date: date5,
                                    time: time5,
                                } = e;
                                let super::super::super::golem::rdbms::types::Date {
                                    year: year6,
                                    month: month6,
                                    day: day6,
                                } = date5;
                                *ptr0.add(8).cast::<i32>() = _rt::as_i32(year6);
                                *ptr0.add(12).cast::<u8>() = (_rt::as_i32(month6)) as u8;
                                *ptr0.add(13).cast::<u8>() = (_rt::as_i32(day6)) as u8;
                                let super::super::super::golem::rdbms::types::Time {
                                    hour: hour7,
                                    minute: minute7,
                                    second: second7,
                                    nanosecond: nanosecond7,
                                } = time5;
                                *ptr0.add(16).cast::<u8>() = (_rt::as_i32(hour7)) as u8;
                                *ptr0.add(17).cast::<u8>() = (_rt::as_i32(minute7)) as u8;
                                *ptr0.add(18).cast::<u8>() = (_rt::as_i32(second7)) as u8;
                                *ptr0.add(20).cast::<i32>() = _rt::as_i32(nanosecond7);
                            }
                            DbValue::Timestamptz(e) => {
                                *ptr0.add(0).cast::<u8>() = (12i32) as u8;
                                let super::super::super::golem::rdbms::types::Timestamptz {
                                    timestamp: timestamp8,
                                    offset: offset8,
                                } = e;
                                let super::super::super::golem::rdbms::types::Timestamp {
                                    date: date9,
                                    time: time9,
                                } = timestamp8;
                                let super::super::super::golem::rdbms::types::Date {
                                    year: year10,
                                    month: month10,
                                    day: day10,
                                } = date9;
                                *ptr0.add(8).cast::<i32>() = _rt::as_i32(year10);
                                *ptr0.add(12).cast::<u8>() = (_rt::as_i32(month10)) as u8;
                                *ptr0.add(13).cast::<u8>() = (_rt::as_i32(day10)) as u8;
                                let super::super::super::golem::rdbms::types::Time {
                                    hour: hour11,
                                    minute: minute11,
                                    second: second11,
                                    nanosecond: nanosecond11,
                                } = time9;
                                *ptr0.add(16).cast::<u8>() = (_rt::as_i32(hour11)) as u8;
                                *ptr0.add(17).cast::<u8>() = (_rt::as_i32(minute11)) as u8;
                                *ptr0.add(18).cast::<u8>() = (_rt::as_i32(second11)) as u8;
                                *ptr0.add(20).cast::<i32>() = _rt::as_i32(nanosecond11);
                                *ptr0.add(24).cast::<i32>() = _rt::as_i32(offset8);
                            }
                            DbValue::Date(e) => {
                                *ptr0.add(0).cast::<u8>() = (13i32) as u8;
                                let super::super::super::golem::rdbms::types::Date {
                                    year: year12,
                                    month: month12,
                                    day: day12,
                                } = e;
                                *ptr0.add(8).cast::<i32>() = _rt::as_i32(year12);
                                *ptr0.add(12).cast::<u8>() = (_rt::as_i32(month12)) as u8;
                                *ptr0.add(13).cast::<u8>() = (_rt::as_i32(day12)) as u8;
                            }
                            DbValue::Time(e) => {
                                *ptr0.add(0).cast::<u8>() = (14i32) as u8;
                                let super::super::super::golem::rdbms::types::Time {
                                    hour: hour13,
                                    minute: minute13,
                                    second: second13,
                                    nanosecond: nanosecond13,
                                } = e;
                                *ptr0.add(8).cast::<u8>() = (_rt::as_i32(hour13)) as u8;
                                *ptr0.add(9).cast::<u8>() = (_rt::as_i32(minute13)) as u8;
                                *ptr0.add(10).cast::<u8>() = (_rt::as_i32(second13)) as u8;
                                *ptr0.add(12).cast::<i32>() = _rt::as_i32(nanosecond13);
                            }
                            DbValue::Timetz(e) => {
                                *ptr0.add(0).cast::<u8>() = (15i32) as u8;
                                let super::super::super::golem::rdbms::types::Timetz {
                                    time: time14,
                                    offset: offset14,
                                } = e;
                                let super::super::super::golem::rdbms::types::Time {
                                    hour: hour15,
                                    minute: minute15,
                                    second: second15,
                                    nanosecond: nanosecond15,
                                } = time14;
                                *ptr0.add(8).cast::<u8>() = (_rt::as_i32(hour15)) as u8;
                                *ptr0.add(9).cast::<u8>() = (_rt::as_i32(minute15)) as u8;
                                *ptr0.add(10).cast::<u8>() = (_rt::as_i32(second15)) as u8;
                                *ptr0.add(12).cast::<i32>() = _rt::as_i32(nanosecond15);
                                *ptr0.add(16).cast::<i32>() = _rt::as_i32(offset14);
                            }
                            DbValue::Interval(e) => {
                                *ptr0.add(0).cast::<u8>() = (16i32) as u8;
                                let Interval {
                                    months: months16,
                                    days: days16,
                                    microseconds: microseconds16,
                                } = e;
                                *ptr0.add(8).cast::<i32>() = _rt::as_i32(months16);
                                *ptr0.add(12).cast::<i32>() = _rt::as_i32(days16);
                                *ptr0.add(16).cast::<i64>() = _rt::as_i64(microseconds16);
                            }
                            DbValue::Bytea(e) => {
                                *ptr0.add(0).cast::<u8>() = (17i32) as u8;
                                let vec17 = e;
                                let ptr17 = vec17.as_ptr().cast::<u8>();
                                let len17 = vec17.len();
                                *ptr0.add(12).cast::<usize>() = len17;
                                *ptr0.add(8).cast::<*mut u8>() = ptr17.cast_mut();
                            }
                            DbValue::Json(e) => {
                                *ptr0.add(0).cast::<u8>() = (18i32) as u8;
                                let vec18 = e;
                                let ptr18 = vec18.as_ptr().cast::<u8>();
                                let len18 = vec18.len();
                                *ptr0.add(12).cast::<usize>() = len18;
                                *ptr0.add(8).cast::<*mut u8>() = ptr18.cast_mut();
                            }
                            DbValue::Jsonb(e) => {
                                *ptr0.add(0).cast::<u8>() = (19i32) as u8;
                                let vec19 = e;
                                let ptr19 = vec19.as_ptr().cast::<u8>();
                                let len19 = vec19.len();
                                *ptr0.add(12).cast::<usize>() = len19;
                                *ptr0.add(8).cast::<*mut u8>() = ptr19.cast_mut();
                            }
                            DbValue::Jsonpath(e) => {
                                *ptr0.add(0).cast::<u8>() = (20i32) as u8;
                                let vec20 = e;
                                let ptr20 = vec20.as_ptr().cast::<u8>();
                                let len20 = vec20.len();
                                *ptr0.add(12).cast::<usize>() = len20;
                                *ptr0.add(8).cast::<*mut u8>() = ptr20.cast_mut();
                            }
                            DbValue::Xml(e) => {
                                *ptr0.add(0).cast::<u8>() = (21i32) as u8;
                                let vec21 = e;
                                let ptr21 = vec21.as_ptr().cast::<u8>();
                                let len21 = vec21.len();
                                *ptr0.add(12).cast::<usize>() = len21;
                                *ptr0.add(8).cast::<*mut u8>() = ptr21.cast_mut();
                            }
                            DbValue::Uuid(e) => {
                                *ptr0.add(0).cast::<u8>() = (22i32) as u8;
                                let super::super::super::golem::rdbms::types::Uuid {
                                    high_bits: high_bits22,
                                    low_bits: low_bits22,
                                } = e;
                                *ptr0.add(8).cast::<i64>() = _rt::as_i64(high_bits22);
                                *ptr0.add(16).cast::<i64>() = _rt::as_i64(low_bits22);
                            }
                            DbValue::Inet(e) => {
                                *ptr0.add(0).cast::<u8>() = (23i32) as u8;
                                use super::super::super::golem::rdbms::types::IpAddress as V25;
                                match e {
                                    V25::Ipv4(e) => {
                                        *ptr0.add(8).cast::<u8>() = (0i32) as u8;
                                        let (t23_0, t23_1, t23_2, t23_3) = e;
                                        *ptr0.add(10).cast::<u8>() = (_rt::as_i32(t23_0)) as u8;
                                        *ptr0.add(11).cast::<u8>() = (_rt::as_i32(t23_1)) as u8;
                                        *ptr0.add(12).cast::<u8>() = (_rt::as_i32(t23_2)) as u8;
                                        *ptr0.add(13).cast::<u8>() = (_rt::as_i32(t23_3)) as u8;
                                    }
                                    V25::Ipv6(e) => {
                                        *ptr0.add(8).cast::<u8>() = (1i32) as u8;
                                        let (
                                            t24_0,
                                            t24_1,
                                            t24_2,
                                            t24_3,
                                            t24_4,
                                            t24_5,
                                            t24_6,
                                            t24_7,
                                        ) = e;
                                        *ptr0.add(10).cast::<u16>() = (_rt::as_i32(t24_0)) as u16;
                                        *ptr0.add(12).cast::<u16>() = (_rt::as_i32(t24_1)) as u16;
                                        *ptr0.add(14).cast::<u16>() = (_rt::as_i32(t24_2)) as u16;
                                        *ptr0.add(16).cast::<u16>() = (_rt::as_i32(t24_3)) as u16;
                                        *ptr0.add(18).cast::<u16>() = (_rt::as_i32(t24_4)) as u16;
                                        *ptr0.add(20).cast::<u16>() = (_rt::as_i32(t24_5)) as u16;
                                        *ptr0.add(22).cast::<u16>() = (_rt::as_i32(t24_6)) as u16;
                                        *ptr0.add(24).cast::<u16>() = (_rt::as_i32(t24_7)) as u16;
                                    }
                                }
                            }
                            DbValue::Cidr(e) => {
                                *ptr0.add(0).cast::<u8>() = (24i32) as u8;
                                use super::super::super::golem::rdbms::types::IpAddress as V28;
                                match e {
                                    V28::Ipv4(e) => {
                                        *ptr0.add(8).cast::<u8>() = (0i32) as u8;
                                        let (t26_0, t26_1, t26_2, t26_3) = e;
                                        *ptr0.add(10).cast::<u8>() = (_rt::as_i32(t26_0)) as u8;
                                        *ptr0.add(11).cast::<u8>() = (_rt::as_i32(t26_1)) as u8;
                                        *ptr0.add(12).cast::<u8>() = (_rt::as_i32(t26_2)) as u8;
                                        *ptr0.add(13).cast::<u8>() = (_rt::as_i32(t26_3)) as u8;
                                    }
                                    V28::Ipv6(e) => {
                                        *ptr0.add(8).cast::<u8>() = (1i32) as u8;
                                        let (
                                            t27_0,
                                            t27_1,
                                            t27_2,
                                            t27_3,
                                            t27_4,
                                            t27_5,
                                            t27_6,
                                            t27_7,
                                        ) = e;
                                        *ptr0.add(10).cast::<u16>() = (_rt::as_i32(t27_0)) as u16;
                                        *ptr0.add(12).cast::<u16>() = (_rt::as_i32(t27_1)) as u16;
                                        *ptr0.add(14).cast::<u16>() = (_rt::as_i32(t27_2)) as u16;
                                        *ptr0.add(16).cast::<u16>() = (_rt::as_i32(t27_3)) as u16;
                                        *ptr0.add(18).cast::<u16>() = (_rt::as_i32(t27_4)) as u16;
                                        *ptr0.add(20).cast::<u16>() = (_rt::as_i32(t27_5)) as u16;
                                        *ptr0.add(22).cast::<u16>() = (_rt::as_i32(t27_6)) as u16;
                                        *ptr0.add(24).cast::<u16>() = (_rt::as_i32(t27_7)) as u16;
                                    }
                                }
                            }
                            DbValue::Macaddr(e) => {
                                *ptr0.add(0).cast::<u8>() = (25i32) as u8;
                                let super::super::super::golem::rdbms::types::MacAddress {
                                    octets: octets29,
                                } = e;
                                let (t30_0, t30_1, t30_2, t30_3, t30_4, t30_5) = octets29;
                                *ptr0.add(8).cast::<u8>() = (_rt::as_i32(t30_0)) as u8;
                                *ptr0.add(9).cast::<u8>() = (_rt::as_i32(t30_1)) as u8;
                                *ptr0.add(10).cast::<u8>() = (_rt::as_i32(t30_2)) as u8;
                                *ptr0.add(11).cast::<u8>() = (_rt::as_i32(t30_3)) as u8;
                                *ptr0.add(12).cast::<u8>() = (_rt::as_i32(t30_4)) as u8;
                                *ptr0.add(13).cast::<u8>() = (_rt::as_i32(t30_5)) as u8;
                            }
                            DbValue::Bit(e) => {
                                *ptr0.add(0).cast::<u8>() = (26i32) as u8;
                                let vec31 = e;
                                let len31 = vec31.len();
                                let layout31 = _rt::alloc::Layout::from_size_align_unchecked(
                                    vec31.len() * 1,
                                    1,
                                );
                                let result31 = if layout31.size() != 0 {
                                    let ptr = _rt::alloc::alloc(layout31).cast::<u8>();
                                    if ptr.is_null() {
                                        _rt::alloc::handle_alloc_error(layout31);
                                    }
                                    ptr
                                } else {
                                    ::core::ptr::null_mut()
                                };
                                for (i, e) in vec31.into_iter().enumerate() {
                                    let base = result31.add(i * 1);
                                    {
                                        *base.add(0).cast::<u8>() = (match e {
                                            true => 1,
                                            false => 0,
                                        }) as u8;
                                    }
                                }
                                *ptr0.add(12).cast::<usize>() = len31;
                                *ptr0.add(8).cast::<*mut u8>() = result31;
                                cleanup_list.extend_from_slice(&[(result31, layout31)]);
                            }
                            DbValue::Varbit(e) => {
                                *ptr0.add(0).cast::<u8>() = (27i32) as u8;
                                let vec32 = e;
                                let len32 = vec32.len();
                                let layout32 = _rt::alloc::Layout::from_size_align_unchecked(
                                    vec32.len() * 1,
                                    1,
                                );
                                let result32 = if layout32.size() != 0 {
                                    let ptr = _rt::alloc::alloc(layout32).cast::<u8>();
                                    if ptr.is_null() {
                                        _rt::alloc::handle_alloc_error(layout32);
                                    }
                                    ptr
                                } else {
                                    ::core::ptr::null_mut()
                                };
                                for (i, e) in vec32.into_iter().enumerate() {
                                    let base = result32.add(i * 1);
                                    {
                                        *base.add(0).cast::<u8>() = (match e {
                                            true => 1,
                                            false => 0,
                                        }) as u8;
                                    }
                                }
                                *ptr0.add(12).cast::<usize>() = len32;
                                *ptr0.add(8).cast::<*mut u8>() = result32;
                                cleanup_list.extend_from_slice(&[(result32, layout32)]);
                            }
                            DbValue::Int4range(e) => {
                                *ptr0.add(0).cast::<u8>() = (28i32) as u8;
                                let Int4range { start: start33, end: end33 } = e;
                                match start33 {
                                    Int4bound::Included(e) => {
                                        *ptr0.add(8).cast::<u8>() = (0i32) as u8;
                                        *ptr0.add(12).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    Int4bound::Excluded(e) => {
                                        *ptr0.add(8).cast::<u8>() = (1i32) as u8;
                                        *ptr0.add(12).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    Int4bound::Unbounded => {
                                        *ptr0.add(8).cast::<u8>() = (2i32) as u8;
                                    }
                                }
                                match end33 {
                                    Int4bound::Included(e) => {
                                        *ptr0.add(16).cast::<u8>() = (0i32) as u8;
                                        *ptr0.add(20).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    Int4bound::Excluded(e) => {
                                        *ptr0.add(16).cast::<u8>() = (1i32) as u8;
                                        *ptr0.add(20).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    Int4bound::Unbounded => {
                                        *ptr0.add(16).cast::<u8>() = (2i32) as u8;
                                    }
                                }
                            }
                            DbValue::Int8range(e) => {
                                *ptr0.add(0).cast::<u8>() = (29i32) as u8;
                                let Int8range { start: start34, end: end34 } = e;
                                match start34 {
                                    Int8bound::Included(e) => {
                                        *ptr0.add(8).cast::<u8>() = (0i32) as u8;
                                        *ptr0.add(16).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    Int8bound::Excluded(e) => {
                                        *ptr0.add(8).cast::<u8>() = (1i32) as u8;
                                        *ptr0.add(16).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    Int8bound::Unbounded => {
                                        *ptr0.add(8).cast::<u8>() = (2i32) as u8;
                                    }
                                }
                                match end34 {
                                    Int8bound::Included(e) => {
                                        *ptr0.add(24).cast::<u8>() = (0i32) as u8;
                                        *ptr0.add(32).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    Int8bound::Excluded(e) => {
                                        *ptr0.add(24).cast::<u8>() = (1i32) as u8;
                                        *ptr0.add(32).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    Int8bound::Unbounded => {
                                        *ptr0.add(24).cast::<u8>() = (2i32) as u8;
                                    }
                                }
                            }
                            DbValue::Numrange(e) => {
                                *ptr0.add(0).cast::<u8>() = (30i32) as u8;
                                let Numrange { start: start35, end: end35 } = e;
                                match start35 {
                                    Numbound::Included(e) => {
                                        *ptr0.add(8).cast::<u8>() = (0i32) as u8;
                                        let vec36 = e;
                                        let ptr36 = vec36.as_ptr().cast::<u8>();
                                        let len36 = vec36.len();
                                        *ptr0.add(16).cast::<usize>() = len36;
                                        *ptr0.add(12).cast::<*mut u8>() = ptr36.cast_mut();
                                    }
                                    Numbound::Excluded(e) => {
                                        *ptr0.add(8).cast::<u8>() = (1i32) as u8;
                                        let vec37 = e;
                                        let ptr37 = vec37.as_ptr().cast::<u8>();
                                        let len37 = vec37.len();
                                        *ptr0.add(16).cast::<usize>() = len37;
                                        *ptr0.add(12).cast::<*mut u8>() = ptr37.cast_mut();
                                    }
                                    Numbound::Unbounded => {
                                        *ptr0.add(8).cast::<u8>() = (2i32) as u8;
                                    }
                                }
                                match end35 {
                                    Numbound::Included(e) => {
                                        *ptr0.add(20).cast::<u8>() = (0i32) as u8;
                                        let vec38 = e;
                                        let ptr38 = vec38.as_ptr().cast::<u8>();
                                        let len38 = vec38.len();
                                        *ptr0.add(28).cast::<usize>() = len38;
                                        *ptr0.add(24).cast::<*mut u8>() = ptr38.cast_mut();
                                    }
                                    Numbound::Excluded(e) => {
                                        *ptr0.add(20).cast::<u8>() = (1i32) as u8;
                                        let vec39 = e;
                                        let ptr39 = vec39.as_ptr().cast::<u8>();
                                        let len39 = vec39.len();
                                        *ptr0.add(28).cast::<usize>() = len39;
                                        *ptr0.add(24).cast::<*mut u8>() = ptr39.cast_mut();
                                    }
                                    Numbound::Unbounded => {
                                        *ptr0.add(20).cast::<u8>() = (2i32) as u8;
                                    }
                                }
                            }
                            DbValue::Tsrange(e) => {
                                *ptr0.add(0).cast::<u8>() = (31i32) as u8;
                                let Tsrange { start: start40, end: end40 } = e;
                                match start40 {
                                    Tsbound::Included(e) => {
                                        *ptr0.add(8).cast::<u8>() = (0i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date41,
                                            time: time41,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year42,
                                            month: month42,
                                            day: day42,
                                        } = date41;
                                        *ptr0.add(12).cast::<i32>() = _rt::as_i32(year42);
                                        *ptr0.add(16).cast::<u8>() = (_rt::as_i32(month42)) as u8;
                                        *ptr0.add(17).cast::<u8>() = (_rt::as_i32(day42)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour43,
                                            minute: minute43,
                                            second: second43,
                                            nanosecond: nanosecond43,
                                        } = time41;
                                        *ptr0.add(20).cast::<u8>() = (_rt::as_i32(hour43)) as u8;
                                        *ptr0.add(21).cast::<u8>() = (_rt::as_i32(minute43)) as u8;
                                        *ptr0.add(22).cast::<u8>() = (_rt::as_i32(second43)) as u8;
                                        *ptr0.add(24).cast::<i32>() = _rt::as_i32(nanosecond43);
                                    }
                                    Tsbound::Excluded(e) => {
                                        *ptr0.add(8).cast::<u8>() = (1i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date44,
                                            time: time44,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year45,
                                            month: month45,
                                            day: day45,
                                        } = date44;
                                        *ptr0.add(12).cast::<i32>() = _rt::as_i32(year45);
                                        *ptr0.add(16).cast::<u8>() = (_rt::as_i32(month45)) as u8;
                                        *ptr0.add(17).cast::<u8>() = (_rt::as_i32(day45)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour46,
                                            minute: minute46,
                                            second: second46,
                                            nanosecond: nanosecond46,
                                        } = time44;
                                        *ptr0.add(20).cast::<u8>() = (_rt::as_i32(hour46)) as u8;
                                        *ptr0.add(21).cast::<u8>() = (_rt::as_i32(minute46)) as u8;
                                        *ptr0.add(22).cast::<u8>() = (_rt::as_i32(second46)) as u8;
                                        *ptr0.add(24).cast::<i32>() = _rt::as_i32(nanosecond46);
                                    }
                                    Tsbound::Unbounded => {
                                        *ptr0.add(8).cast::<u8>() = (2i32) as u8;
                                    }
                                }
                                match end40 {
                                    Tsbound::Included(e) => {
                                        *ptr0.add(28).cast::<u8>() = (0i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date47,
                                            time: time47,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year48,
                                            month: month48,
                                            day: day48,
                                        } = date47;
                                        *ptr0.add(32).cast::<i32>() = _rt::as_i32(year48);
                                        *ptr0.add(36).cast::<u8>() = (_rt::as_i32(month48)) as u8;
                                        *ptr0.add(37).cast::<u8>() = (_rt::as_i32(day48)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour49,
                                            minute: minute49,
                                            second: second49,
                                            nanosecond: nanosecond49,
                                        } = time47;
                                        *ptr0.add(40).cast::<u8>() = (_rt::as_i32(hour49)) as u8;
                                        *ptr0.add(41).cast::<u8>() = (_rt::as_i32(minute49)) as u8;
                                        *ptr0.add(42).cast::<u8>() = (_rt::as_i32(second49)) as u8;
                                        *ptr0.add(44).cast::<i32>() = _rt::as_i32(nanosecond49);
                                    }
                                    Tsbound::Excluded(e) => {
                                        *ptr0.add(28).cast::<u8>() = (1i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date50,
                                            time: time50,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year51,
                                            month: month51,
                                            day: day51,
                                        } = date50;
                                        *ptr0.add(32).cast::<i32>() = _rt::as_i32(year51);
                                        *ptr0.add(36).cast::<u8>() = (_rt::as_i32(month51)) as u8;
                                        *ptr0.add(37).cast::<u8>() = (_rt::as_i32(day51)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour52,
                                            minute: minute52,
                                            second: second52,
                                            nanosecond: nanosecond52,
                                        } = time50;
                                        *ptr0.add(40).cast::<u8>() = (_rt::as_i32(hour52)) as u8;
                                        *ptr0.add(41).cast::<u8>() = (_rt::as_i32(minute52)) as u8;
                                        *ptr0.add(42).cast::<u8>() = (_rt::as_i32(second52)) as u8;
                                        *ptr0.add(44).cast::<i32>() = _rt::as_i32(nanosecond52);
                                    }
                                    Tsbound::Unbounded => {
                                        *ptr0.add(28).cast::<u8>() = (2i32) as u8;
                                    }
                                }
                            }
                            DbValue::Tstzrange(e) => {
                                *ptr0.add(0).cast::<u8>() = (32i32) as u8;
                                let Tstzrange { start: start53, end: end53 } = e;
                                match start53 {
                                    Tstzbound::Included(e) => {
                                        *ptr0.add(8).cast::<u8>() = (0i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamptz {
                                            timestamp: timestamp54,
                                            offset: offset54,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date55,
                                            time: time55,
                                        } = timestamp54;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year56,
                                            month: month56,
                                            day: day56,
                                        } = date55;
                                        *ptr0.add(12).cast::<i32>() = _rt::as_i32(year56);
                                        *ptr0.add(16).cast::<u8>() = (_rt::as_i32(month56)) as u8;
                                        *ptr0.add(17).cast::<u8>() = (_rt::as_i32(day56)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour57,
                                            minute: minute57,
                                            second: second57,
                                            nanosecond: nanosecond57,
                                        } = time55;
                                        *ptr0.add(20).cast::<u8>() = (_rt::as_i32(hour57)) as u8;
                                        *ptr0.add(21).cast::<u8>() = (_rt::as_i32(minute57)) as u8;
                                        *ptr0.add(22).cast::<u8>() = (_rt::as_i32(second57)) as u8;
                                        *ptr0.add(24).cast::<i32>() = _rt::as_i32(nanosecond57);
                                        *ptr0.add(28).cast::<i32>() = _rt::as_i32(offset54);
                                    }
                                    Tstzbound::Excluded(e) => {
                                        *ptr0.add(8).cast::<u8>() = (1i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamptz {
                                            timestamp: timestamp58,
                                            offset: offset58,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date59,
                                            time: time59,
                                        } = timestamp58;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year60,
                                            month: month60,
                                            day: day60,
                                        } = date59;
                                        *ptr0.add(12).cast::<i32>() = _rt::as_i32(year60);
                                        *ptr0.add(16).cast::<u8>() = (_rt::as_i32(month60)) as u8;
                                        *ptr0.add(17).cast::<u8>() = (_rt::as_i32(day60)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour61,
                                            minute: minute61,
                                            second: second61,
                                            nanosecond: nanosecond61,
                                        } = time59;
                                        *ptr0.add(20).cast::<u8>() = (_rt::as_i32(hour61)) as u8;
                                        *ptr0.add(21).cast::<u8>() = (_rt::as_i32(minute61)) as u8;
                                        *ptr0.add(22).cast::<u8>() = (_rt::as_i32(second61)) as u8;
                                        *ptr0.add(24).cast::<i32>() = _rt::as_i32(nanosecond61);
                                        *ptr0.add(28).cast::<i32>() = _rt::as_i32(offset58);
                                    }
                                    Tstzbound::Unbounded => {
                                        *ptr0.add(8).cast::<u8>() = (2i32) as u8;
                                    }
                                }
                                match end53 {
                                    Tstzbound::Included(e) => {
                                        *ptr0.add(32).cast::<u8>() = (0i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamptz {
                                            timestamp: timestamp62,
                                            offset: offset62,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date63,
                                            time: time63,
                                        } = timestamp62;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year64,
                                            month: month64,
                                            day: day64,
                                        } = date63;
                                        *ptr0.add(36).cast::<i32>() = _rt::as_i32(year64);
                                        *ptr0.add(40).cast::<u8>() = (_rt::as_i32(month64)) as u8;
                                        *ptr0.add(41).cast::<u8>() = (_rt::as_i32(day64)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour65,
                                            minute: minute65,
                                            second: second65,
                                            nanosecond: nanosecond65,
                                        } = time63;
                                        *ptr0.add(44).cast::<u8>() = (_rt::as_i32(hour65)) as u8;
                                        *ptr0.add(45).cast::<u8>() = (_rt::as_i32(minute65)) as u8;
                                        *ptr0.add(46).cast::<u8>() = (_rt::as_i32(second65)) as u8;
                                        *ptr0.add(48).cast::<i32>() = _rt::as_i32(nanosecond65);
                                        *ptr0.add(52).cast::<i32>() = _rt::as_i32(offset62);
                                    }
                                    Tstzbound::Excluded(e) => {
                                        *ptr0.add(32).cast::<u8>() = (1i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamptz {
                                            timestamp: timestamp66,
                                            offset: offset66,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date67,
                                            time: time67,
                                        } = timestamp66;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year68,
                                            month: month68,
                                            day: day68,
                                        } = date67;
                                        *ptr0.add(36).cast::<i32>() = _rt::as_i32(year68);
                                        *ptr0.add(40).cast::<u8>() = (_rt::as_i32(month68)) as u8;
                                        *ptr0.add(41).cast::<u8>() = (_rt::as_i32(day68)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour69,
                                            minute: minute69,
                                            second: second69,
                                            nanosecond: nanosecond69,
                                        } = time67;
                                        *ptr0.add(44).cast::<u8>() = (_rt::as_i32(hour69)) as u8;
                                        *ptr0.add(45).cast::<u8>() = (_rt::as_i32(minute69)) as u8;
                                        *ptr0.add(46).cast::<u8>() = (_rt::as_i32(second69)) as u8;
                                        *ptr0.add(48).cast::<i32>() = _rt::as_i32(nanosecond69);
                                        *ptr0.add(52).cast::<i32>() = _rt::as_i32(offset66);
                                    }
                                    Tstzbound::Unbounded => {
                                        *ptr0.add(32).cast::<u8>() = (2i32) as u8;
                                    }
                                }
                            }
                            DbValue::Daterange(e) => {
                                *ptr0.add(0).cast::<u8>() = (33i32) as u8;
                                let Daterange { start: start70, end: end70 } = e;
                                match start70 {
                                    Datebound::Included(e) => {
                                        *ptr0.add(8).cast::<u8>() = (0i32) as u8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year71,
                                            month: month71,
                                            day: day71,
                                        } = e;
                                        *ptr0.add(12).cast::<i32>() = _rt::as_i32(year71);
                                        *ptr0.add(16).cast::<u8>() = (_rt::as_i32(month71)) as u8;
                                        *ptr0.add(17).cast::<u8>() = (_rt::as_i32(day71)) as u8;
                                    }
                                    Datebound::Excluded(e) => {
                                        *ptr0.add(8).cast::<u8>() = (1i32) as u8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year72,
                                            month: month72,
                                            day: day72,
                                        } = e;
                                        *ptr0.add(12).cast::<i32>() = _rt::as_i32(year72);
                                        *ptr0.add(16).cast::<u8>() = (_rt::as_i32(month72)) as u8;
                                        *ptr0.add(17).cast::<u8>() = (_rt::as_i32(day72)) as u8;
                                    }
                                    Datebound::Unbounded => {
                                        *ptr0.add(8).cast::<u8>() = (2i32) as u8;
                                    }
                                }
                                match end70 {
                                    Datebound::Included(e) => {
                                        *ptr0.add(20).cast::<u8>() = (0i32) as u8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year73,
                                            month: month73,
                                            day: day73,
                                        } = e;
                                        *ptr0.add(24).cast::<i32>() = _rt::as_i32(year73);
                                        *ptr0.add(28).cast::<u8>() = (_rt::as_i32(month73)) as u8;
                                        *ptr0.add(29).cast::<u8>() = (_rt::as_i32(day73)) as u8;
                                    }
                                    Datebound::Excluded(e) => {
                                        *ptr0.add(20).cast::<u8>() = (1i32) as u8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year74,
                                            month: month74,
                                            day: day74,
                                        } = e;
                                        *ptr0.add(24).cast::<i32>() = _rt::as_i32(year74);
                                        *ptr0.add(28).cast::<u8>() = (_rt::as_i32(month74)) as u8;
                                        *ptr0.add(29).cast::<u8>() = (_rt::as_i32(day74)) as u8;
                                    }
                                    Datebound::Unbounded => {
                                        *ptr0.add(20).cast::<u8>() = (2i32) as u8;
                                    }
                                }
                            }
                            DbValue::Money(e) => {
                                *ptr0.add(0).cast::<u8>() = (34i32) as u8;
                                *ptr0.add(8).cast::<i64>() = _rt::as_i64(e);
                            }
                            DbValue::Oid(e) => {
                                *ptr0.add(0).cast::<u8>() = (35i32) as u8;
                                *ptr0.add(8).cast::<i32>() = _rt::as_i32(e);
                            }
                            DbValue::Enumeration(e) => {
                                *ptr0.add(0).cast::<u8>() = (36i32) as u8;
                                let Enumeration { name: name75, value: value75 } = e;
                                let vec76 = name75;
                                let ptr76 = vec76.as_ptr().cast::<u8>();
                                let len76 = vec76.len();
                                *ptr0.add(12).cast::<usize>() = len76;
                                *ptr0.add(8).cast::<*mut u8>() = ptr76.cast_mut();
                                let vec77 = value75;
                                let ptr77 = vec77.as_ptr().cast::<u8>();
                                let len77 = vec77.len();
                                *ptr0.add(20).cast::<usize>() = len77;
                                *ptr0.add(16).cast::<*mut u8>() = ptr77.cast_mut();
                            }
                            DbValue::Composite(e) => {
                                *ptr0.add(0).cast::<u8>() = (37i32) as u8;
                                let Composite { name: name78, values: values78 } = e;
                                let vec79 = name78;
                                let ptr79 = vec79.as_ptr().cast::<u8>();
                                let len79 = vec79.len();
                                *ptr0.add(12).cast::<usize>() = len79;
                                *ptr0.add(8).cast::<*mut u8>() = ptr79.cast_mut();
                                let vec80 = values78;
                                let len80 = vec80.len();
                                let layout80 = _rt::alloc::Layout::from_size_align_unchecked(
                                    vec80.len() * 4,
                                    4,
                                );
                                let result80 = if layout80.size() != 0 {
                                    let ptr = _rt::alloc::alloc(layout80).cast::<u8>();
                                    if ptr.is_null() {
                                        _rt::alloc::handle_alloc_error(layout80);
                                    }
                                    ptr
                                } else {
                                    ::core::ptr::null_mut()
                                };
                                for (i, e) in vec80.into_iter().enumerate() {
                                    let base = result80.add(i * 4);
                                    {
                                        *base.add(0).cast::<i32>() = (e).take_handle() as i32;
                                    }
                                }
                                *ptr0.add(20).cast::<usize>() = len80;
                                *ptr0.add(16).cast::<*mut u8>() = result80;
                                cleanup_list.extend_from_slice(&[(result80, layout80)]);
                            }
                            DbValue::Domain(e) => {
                                *ptr0.add(0).cast::<u8>() = (38i32) as u8;
                                let Domain { name: name81, value: value81 } = e;
                                let vec82 = name81;
                                let ptr82 = vec82.as_ptr().cast::<u8>();
                                let len82 = vec82.len();
                                *ptr0.add(12).cast::<usize>() = len82;
                                *ptr0.add(8).cast::<*mut u8>() = ptr82.cast_mut();
                                *ptr0.add(16).cast::<i32>() = (value81).take_handle()
                                    as i32;
                            }
                            DbValue::Array(e) => {
                                *ptr0.add(0).cast::<u8>() = (39i32) as u8;
                                let vec83 = e;
                                let len83 = vec83.len();
                                let layout83 = _rt::alloc::Layout::from_size_align_unchecked(
                                    vec83.len() * 4,
                                    4,
                                );
                                let result83 = if layout83.size() != 0 {
                                    let ptr = _rt::alloc::alloc(layout83).cast::<u8>();
                                    if ptr.is_null() {
                                        _rt::alloc::handle_alloc_error(layout83);
                                    }
                                    ptr
                                } else {
                                    ::core::ptr::null_mut()
                                };
                                for (i, e) in vec83.into_iter().enumerate() {
                                    let base = result83.add(i * 4);
                                    {
                                        *base.add(0).cast::<i32>() = (e).take_handle() as i32;
                                    }
                                }
                                *ptr0.add(12).cast::<usize>() = len83;
                                *ptr0.add(8).cast::<*mut u8>() = result83;
                                cleanup_list.extend_from_slice(&[(result83, layout83)]);
                            }
                            DbValue::Range(e) => {
                                *ptr0.add(0).cast::<u8>() = (40i32) as u8;
                                let Range { name: name84, value: value84 } = e;
                                let vec85 = name84;
                                let ptr85 = vec85.as_ptr().cast::<u8>();
                                let len85 = vec85.len();
                                *ptr0.add(12).cast::<usize>() = len85;
                                *ptr0.add(8).cast::<*mut u8>() = ptr85.cast_mut();
                                let ValuesRange { start: start86, end: end86 } = value84;
                                match start86 {
                                    ValueBound::Included(e) => {
                                        *ptr0.add(16).cast::<u8>() = (0i32) as u8;
                                        *ptr0.add(20).cast::<i32>() = (e).take_handle() as i32;
                                    }
                                    ValueBound::Excluded(e) => {
                                        *ptr0.add(16).cast::<u8>() = (1i32) as u8;
                                        *ptr0.add(20).cast::<i32>() = (e).take_handle() as i32;
                                    }
                                    ValueBound::Unbounded => {
                                        *ptr0.add(16).cast::<u8>() = (2i32) as u8;
                                    }
                                }
                                match end86 {
                                    ValueBound::Included(e) => {
                                        *ptr0.add(24).cast::<u8>() = (0i32) as u8;
                                        *ptr0.add(28).cast::<i32>() = (e).take_handle() as i32;
                                    }
                                    ValueBound::Excluded(e) => {
                                        *ptr0.add(24).cast::<u8>() = (1i32) as u8;
                                        *ptr0.add(28).cast::<i32>() = (e).take_handle() as i32;
                                    }
                                    ValueBound::Unbounded => {
                                        *ptr0.add(24).cast::<u8>() = (2i32) as u8;
                                    }
                                }
                            }
                            DbValue::Null => {
                                *ptr0.add(0).cast::<u8>() = (41i32) as u8;
                            }
                        }
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rdbms/postgres@0.0.1")]
                        extern "C" {
                            #[link_name = "[constructor]lazy-db-value"]
                            fn wit_import(_: *mut u8) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: *mut u8) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import(ptr0);
                        for (ptr, layout) in cleanup_list {
                            if layout.size() != 0 {
                                _rt::alloc::dealloc(ptr.cast(), layout);
                            }
                        }
                        LazyDbValue::from_handle(ret as u32)
                    }
                }
            }
            impl LazyDbValue {
                #[allow(unused_unsafe, clippy::all)]
                pub fn get(&self) -> DbValue {
                    unsafe {
                        #[repr(align(8))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 56]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 56],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rdbms/postgres@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]lazy-db-value.get"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        let v260 = match l1 {
                            0 => {
                                let e260 = {
                                    let l2 = i32::from(*ptr0.add(8).cast::<i8>());
                                    l2 as i8
                                };
                                DbValue::Character(e260)
                            }
                            1 => {
                                let e260 = {
                                    let l3 = i32::from(*ptr0.add(8).cast::<i16>());
                                    l3 as i16
                                };
                                DbValue::Int2(e260)
                            }
                            2 => {
                                let e260 = {
                                    let l4 = *ptr0.add(8).cast::<i32>();
                                    l4
                                };
                                DbValue::Int4(e260)
                            }
                            3 => {
                                let e260 = {
                                    let l5 = *ptr0.add(8).cast::<i64>();
                                    l5
                                };
                                DbValue::Int8(e260)
                            }
                            4 => {
                                let e260 = {
                                    let l6 = *ptr0.add(8).cast::<f32>();
                                    l6
                                };
                                DbValue::Float4(e260)
                            }
                            5 => {
                                let e260 = {
                                    let l7 = *ptr0.add(8).cast::<f64>();
                                    l7
                                };
                                DbValue::Float8(e260)
                            }
                            6 => {
                                let e260 = {
                                    let l8 = *ptr0.add(8).cast::<*mut u8>();
                                    let l9 = *ptr0.add(12).cast::<usize>();
                                    let len10 = l9;
                                    let bytes10 = _rt::Vec::from_raw_parts(
                                        l8.cast(),
                                        len10,
                                        len10,
                                    );
                                    _rt::string_lift(bytes10)
                                };
                                DbValue::Numeric(e260)
                            }
                            7 => {
                                let e260 = {
                                    let l11 = i32::from(*ptr0.add(8).cast::<u8>());
                                    _rt::bool_lift(l11 as u8)
                                };
                                DbValue::Boolean(e260)
                            }
                            8 => {
                                let e260 = {
                                    let l12 = *ptr0.add(8).cast::<*mut u8>();
                                    let l13 = *ptr0.add(12).cast::<usize>();
                                    let len14 = l13;
                                    let bytes14 = _rt::Vec::from_raw_parts(
                                        l12.cast(),
                                        len14,
                                        len14,
                                    );
                                    _rt::string_lift(bytes14)
                                };
                                DbValue::Text(e260)
                            }
                            9 => {
                                let e260 = {
                                    let l15 = *ptr0.add(8).cast::<*mut u8>();
                                    let l16 = *ptr0.add(12).cast::<usize>();
                                    let len17 = l16;
                                    let bytes17 = _rt::Vec::from_raw_parts(
                                        l15.cast(),
                                        len17,
                                        len17,
                                    );
                                    _rt::string_lift(bytes17)
                                };
                                DbValue::Varchar(e260)
                            }
                            10 => {
                                let e260 = {
                                    let l18 = *ptr0.add(8).cast::<*mut u8>();
                                    let l19 = *ptr0.add(12).cast::<usize>();
                                    let len20 = l19;
                                    let bytes20 = _rt::Vec::from_raw_parts(
                                        l18.cast(),
                                        len20,
                                        len20,
                                    );
                                    _rt::string_lift(bytes20)
                                };
                                DbValue::Bpchar(e260)
                            }
                            11 => {
                                let e260 = {
                                    let l21 = *ptr0.add(8).cast::<i32>();
                                    let l22 = i32::from(*ptr0.add(12).cast::<u8>());
                                    let l23 = i32::from(*ptr0.add(13).cast::<u8>());
                                    let l24 = i32::from(*ptr0.add(16).cast::<u8>());
                                    let l25 = i32::from(*ptr0.add(17).cast::<u8>());
                                    let l26 = i32::from(*ptr0.add(18).cast::<u8>());
                                    let l27 = *ptr0.add(20).cast::<i32>();
                                    super::super::super::golem::rdbms::types::Timestamp {
                                        date: super::super::super::golem::rdbms::types::Date {
                                            year: l21,
                                            month: l22 as u8,
                                            day: l23 as u8,
                                        },
                                        time: super::super::super::golem::rdbms::types::Time {
                                            hour: l24 as u8,
                                            minute: l25 as u8,
                                            second: l26 as u8,
                                            nanosecond: l27 as u32,
                                        },
                                    }
                                };
                                DbValue::Timestamp(e260)
                            }
                            12 => {
                                let e260 = {
                                    let l28 = *ptr0.add(8).cast::<i32>();
                                    let l29 = i32::from(*ptr0.add(12).cast::<u8>());
                                    let l30 = i32::from(*ptr0.add(13).cast::<u8>());
                                    let l31 = i32::from(*ptr0.add(16).cast::<u8>());
                                    let l32 = i32::from(*ptr0.add(17).cast::<u8>());
                                    let l33 = i32::from(*ptr0.add(18).cast::<u8>());
                                    let l34 = *ptr0.add(20).cast::<i32>();
                                    let l35 = *ptr0.add(24).cast::<i32>();
                                    super::super::super::golem::rdbms::types::Timestamptz {
                                        timestamp: super::super::super::golem::rdbms::types::Timestamp {
                                            date: super::super::super::golem::rdbms::types::Date {
                                                year: l28,
                                                month: l29 as u8,
                                                day: l30 as u8,
                                            },
                                            time: super::super::super::golem::rdbms::types::Time {
                                                hour: l31 as u8,
                                                minute: l32 as u8,
                                                second: l33 as u8,
                                                nanosecond: l34 as u32,
                                            },
                                        },
                                        offset: l35,
                                    }
                                };
                                DbValue::Timestamptz(e260)
                            }
                            13 => {
                                let e260 = {
                                    let l36 = *ptr0.add(8).cast::<i32>();
                                    let l37 = i32::from(*ptr0.add(12).cast::<u8>());
                                    let l38 = i32::from(*ptr0.add(13).cast::<u8>());
                                    super::super::super::golem::rdbms::types::Date {
                                        year: l36,
                                        month: l37 as u8,
                                        day: l38 as u8,
                                    }
                                };
                                DbValue::Date(e260)
                            }
                            14 => {
                                let e260 = {
                                    let l39 = i32::from(*ptr0.add(8).cast::<u8>());
                                    let l40 = i32::from(*ptr0.add(9).cast::<u8>());
                                    let l41 = i32::from(*ptr0.add(10).cast::<u8>());
                                    let l42 = *ptr0.add(12).cast::<i32>();
                                    super::super::super::golem::rdbms::types::Time {
                                        hour: l39 as u8,
                                        minute: l40 as u8,
                                        second: l41 as u8,
                                        nanosecond: l42 as u32,
                                    }
                                };
                                DbValue::Time(e260)
                            }
                            15 => {
                                let e260 = {
                                    let l43 = i32::from(*ptr0.add(8).cast::<u8>());
                                    let l44 = i32::from(*ptr0.add(9).cast::<u8>());
                                    let l45 = i32::from(*ptr0.add(10).cast::<u8>());
                                    let l46 = *ptr0.add(12).cast::<i32>();
                                    let l47 = *ptr0.add(16).cast::<i32>();
                                    super::super::super::golem::rdbms::types::Timetz {
                                        time: super::super::super::golem::rdbms::types::Time {
                                            hour: l43 as u8,
                                            minute: l44 as u8,
                                            second: l45 as u8,
                                            nanosecond: l46 as u32,
                                        },
                                        offset: l47,
                                    }
                                };
                                DbValue::Timetz(e260)
                            }
                            16 => {
                                let e260 = {
                                    let l48 = *ptr0.add(8).cast::<i32>();
                                    let l49 = *ptr0.add(12).cast::<i32>();
                                    let l50 = *ptr0.add(16).cast::<i64>();
                                    Interval {
                                        months: l48,
                                        days: l49,
                                        microseconds: l50,
                                    }
                                };
                                DbValue::Interval(e260)
                            }
                            17 => {
                                let e260 = {
                                    let l51 = *ptr0.add(8).cast::<*mut u8>();
                                    let l52 = *ptr0.add(12).cast::<usize>();
                                    let len53 = l52;
                                    _rt::Vec::from_raw_parts(l51.cast(), len53, len53)
                                };
                                DbValue::Bytea(e260)
                            }
                            18 => {
                                let e260 = {
                                    let l54 = *ptr0.add(8).cast::<*mut u8>();
                                    let l55 = *ptr0.add(12).cast::<usize>();
                                    let len56 = l55;
                                    let bytes56 = _rt::Vec::from_raw_parts(
                                        l54.cast(),
                                        len56,
                                        len56,
                                    );
                                    _rt::string_lift(bytes56)
                                };
                                DbValue::Json(e260)
                            }
                            19 => {
                                let e260 = {
                                    let l57 = *ptr0.add(8).cast::<*mut u8>();
                                    let l58 = *ptr0.add(12).cast::<usize>();
                                    let len59 = l58;
                                    let bytes59 = _rt::Vec::from_raw_parts(
                                        l57.cast(),
                                        len59,
                                        len59,
                                    );
                                    _rt::string_lift(bytes59)
                                };
                                DbValue::Jsonb(e260)
                            }
                            20 => {
                                let e260 = {
                                    let l60 = *ptr0.add(8).cast::<*mut u8>();
                                    let l61 = *ptr0.add(12).cast::<usize>();
                                    let len62 = l61;
                                    let bytes62 = _rt::Vec::from_raw_parts(
                                        l60.cast(),
                                        len62,
                                        len62,
                                    );
                                    _rt::string_lift(bytes62)
                                };
                                DbValue::Jsonpath(e260)
                            }
                            21 => {
                                let e260 = {
                                    let l63 = *ptr0.add(8).cast::<*mut u8>();
                                    let l64 = *ptr0.add(12).cast::<usize>();
                                    let len65 = l64;
                                    let bytes65 = _rt::Vec::from_raw_parts(
                                        l63.cast(),
                                        len65,
                                        len65,
                                    );
                                    _rt::string_lift(bytes65)
                                };
                                DbValue::Xml(e260)
                            }
                            22 => {
                                let e260 = {
                                    let l66 = *ptr0.add(8).cast::<i64>();
                                    let l67 = *ptr0.add(16).cast::<i64>();
                                    super::super::super::golem::rdbms::types::Uuid {
                                        high_bits: l66 as u64,
                                        low_bits: l67 as u64,
                                    }
                                };
                                DbValue::Uuid(e260)
                            }
                            23 => {
                                let e260 = {
                                    let l68 = i32::from(*ptr0.add(8).cast::<u8>());
                                    use super::super::super::golem::rdbms::types::IpAddress as V81;
                                    let v81 = match l68 {
                                        0 => {
                                            let e81 = {
                                                let l69 = i32::from(*ptr0.add(10).cast::<u8>());
                                                let l70 = i32::from(*ptr0.add(11).cast::<u8>());
                                                let l71 = i32::from(*ptr0.add(12).cast::<u8>());
                                                let l72 = i32::from(*ptr0.add(13).cast::<u8>());
                                                (l69 as u8, l70 as u8, l71 as u8, l72 as u8)
                                            };
                                            V81::Ipv4(e81)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 1, "invalid enum discriminant");
                                            let e81 = {
                                                let l73 = i32::from(*ptr0.add(10).cast::<u16>());
                                                let l74 = i32::from(*ptr0.add(12).cast::<u16>());
                                                let l75 = i32::from(*ptr0.add(14).cast::<u16>());
                                                let l76 = i32::from(*ptr0.add(16).cast::<u16>());
                                                let l77 = i32::from(*ptr0.add(18).cast::<u16>());
                                                let l78 = i32::from(*ptr0.add(20).cast::<u16>());
                                                let l79 = i32::from(*ptr0.add(22).cast::<u16>());
                                                let l80 = i32::from(*ptr0.add(24).cast::<u16>());
                                                (
                                                    l73 as u16,
                                                    l74 as u16,
                                                    l75 as u16,
                                                    l76 as u16,
                                                    l77 as u16,
                                                    l78 as u16,
                                                    l79 as u16,
                                                    l80 as u16,
                                                )
                                            };
                                            V81::Ipv6(e81)
                                        }
                                    };
                                    v81
                                };
                                DbValue::Inet(e260)
                            }
                            24 => {
                                let e260 = {
                                    let l82 = i32::from(*ptr0.add(8).cast::<u8>());
                                    use super::super::super::golem::rdbms::types::IpAddress as V95;
                                    let v95 = match l82 {
                                        0 => {
                                            let e95 = {
                                                let l83 = i32::from(*ptr0.add(10).cast::<u8>());
                                                let l84 = i32::from(*ptr0.add(11).cast::<u8>());
                                                let l85 = i32::from(*ptr0.add(12).cast::<u8>());
                                                let l86 = i32::from(*ptr0.add(13).cast::<u8>());
                                                (l83 as u8, l84 as u8, l85 as u8, l86 as u8)
                                            };
                                            V95::Ipv4(e95)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 1, "invalid enum discriminant");
                                            let e95 = {
                                                let l87 = i32::from(*ptr0.add(10).cast::<u16>());
                                                let l88 = i32::from(*ptr0.add(12).cast::<u16>());
                                                let l89 = i32::from(*ptr0.add(14).cast::<u16>());
                                                let l90 = i32::from(*ptr0.add(16).cast::<u16>());
                                                let l91 = i32::from(*ptr0.add(18).cast::<u16>());
                                                let l92 = i32::from(*ptr0.add(20).cast::<u16>());
                                                let l93 = i32::from(*ptr0.add(22).cast::<u16>());
                                                let l94 = i32::from(*ptr0.add(24).cast::<u16>());
                                                (
                                                    l87 as u16,
                                                    l88 as u16,
                                                    l89 as u16,
                                                    l90 as u16,
                                                    l91 as u16,
                                                    l92 as u16,
                                                    l93 as u16,
                                                    l94 as u16,
                                                )
                                            };
                                            V95::Ipv6(e95)
                                        }
                                    };
                                    v95
                                };
                                DbValue::Cidr(e260)
                            }
                            25 => {
                                let e260 = {
                                    let l96 = i32::from(*ptr0.add(8).cast::<u8>());
                                    let l97 = i32::from(*ptr0.add(9).cast::<u8>());
                                    let l98 = i32::from(*ptr0.add(10).cast::<u8>());
                                    let l99 = i32::from(*ptr0.add(11).cast::<u8>());
                                    let l100 = i32::from(*ptr0.add(12).cast::<u8>());
                                    let l101 = i32::from(*ptr0.add(13).cast::<u8>());
                                    super::super::super::golem::rdbms::types::MacAddress {
                                        octets: (
                                            l96 as u8,
                                            l97 as u8,
                                            l98 as u8,
                                            l99 as u8,
                                            l100 as u8,
                                            l101 as u8,
                                        ),
                                    }
                                };
                                DbValue::Macaddr(e260)
                            }
                            26 => {
                                let e260 = {
                                    let l102 = *ptr0.add(8).cast::<*mut u8>();
                                    let l103 = *ptr0.add(12).cast::<usize>();
                                    let base105 = l102;
                                    let len105 = l103;
                                    let mut result105 = _rt::Vec::with_capacity(len105);
                                    for i in 0..len105 {
                                        let base = base105.add(i * 1);
                                        let e105 = {
                                            let l104 = i32::from(*base.add(0).cast::<u8>());
                                            _rt::bool_lift(l104 as u8)
                                        };
                                        result105.push(e105);
                                    }
                                    _rt::cabi_dealloc(base105, len105 * 1, 1);
                                    result105
                                };
                                DbValue::Bit(e260)
                            }
                            27 => {
                                let e260 = {
                                    let l106 = *ptr0.add(8).cast::<*mut u8>();
                                    let l107 = *ptr0.add(12).cast::<usize>();
                                    let base109 = l106;
                                    let len109 = l107;
                                    let mut result109 = _rt::Vec::with_capacity(len109);
                                    for i in 0..len109 {
                                        let base = base109.add(i * 1);
                                        let e109 = {
                                            let l108 = i32::from(*base.add(0).cast::<u8>());
                                            _rt::bool_lift(l108 as u8)
                                        };
                                        result109.push(e109);
                                    }
                                    _rt::cabi_dealloc(base109, len109 * 1, 1);
                                    result109
                                };
                                DbValue::Varbit(e260)
                            }
                            28 => {
                                let e260 = {
                                    let l110 = i32::from(*ptr0.add(8).cast::<u8>());
                                    let v113 = match l110 {
                                        0 => {
                                            let e113 = {
                                                let l111 = *ptr0.add(12).cast::<i32>();
                                                l111
                                            };
                                            Int4bound::Included(e113)
                                        }
                                        1 => {
                                            let e113 = {
                                                let l112 = *ptr0.add(12).cast::<i32>();
                                                l112
                                            };
                                            Int4bound::Excluded(e113)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            Int4bound::Unbounded
                                        }
                                    };
                                    let l114 = i32::from(*ptr0.add(16).cast::<u8>());
                                    let v117 = match l114 {
                                        0 => {
                                            let e117 = {
                                                let l115 = *ptr0.add(20).cast::<i32>();
                                                l115
                                            };
                                            Int4bound::Included(e117)
                                        }
                                        1 => {
                                            let e117 = {
                                                let l116 = *ptr0.add(20).cast::<i32>();
                                                l116
                                            };
                                            Int4bound::Excluded(e117)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            Int4bound::Unbounded
                                        }
                                    };
                                    Int4range {
                                        start: v113,
                                        end: v117,
                                    }
                                };
                                DbValue::Int4range(e260)
                            }
                            29 => {
                                let e260 = {
                                    let l118 = i32::from(*ptr0.add(8).cast::<u8>());
                                    let v121 = match l118 {
                                        0 => {
                                            let e121 = {
                                                let l119 = *ptr0.add(16).cast::<i64>();
                                                l119
                                            };
                                            Int8bound::Included(e121)
                                        }
                                        1 => {
                                            let e121 = {
                                                let l120 = *ptr0.add(16).cast::<i64>();
                                                l120
                                            };
                                            Int8bound::Excluded(e121)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            Int8bound::Unbounded
                                        }
                                    };
                                    let l122 = i32::from(*ptr0.add(24).cast::<u8>());
                                    let v125 = match l122 {
                                        0 => {
                                            let e125 = {
                                                let l123 = *ptr0.add(32).cast::<i64>();
                                                l123
                                            };
                                            Int8bound::Included(e125)
                                        }
                                        1 => {
                                            let e125 = {
                                                let l124 = *ptr0.add(32).cast::<i64>();
                                                l124
                                            };
                                            Int8bound::Excluded(e125)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            Int8bound::Unbounded
                                        }
                                    };
                                    Int8range {
                                        start: v121,
                                        end: v125,
                                    }
                                };
                                DbValue::Int8range(e260)
                            }
                            30 => {
                                let e260 = {
                                    let l126 = i32::from(*ptr0.add(8).cast::<u8>());
                                    let v133 = match l126 {
                                        0 => {
                                            let e133 = {
                                                let l127 = *ptr0.add(12).cast::<*mut u8>();
                                                let l128 = *ptr0.add(16).cast::<usize>();
                                                let len129 = l128;
                                                let bytes129 = _rt::Vec::from_raw_parts(
                                                    l127.cast(),
                                                    len129,
                                                    len129,
                                                );
                                                _rt::string_lift(bytes129)
                                            };
                                            Numbound::Included(e133)
                                        }
                                        1 => {
                                            let e133 = {
                                                let l130 = *ptr0.add(12).cast::<*mut u8>();
                                                let l131 = *ptr0.add(16).cast::<usize>();
                                                let len132 = l131;
                                                let bytes132 = _rt::Vec::from_raw_parts(
                                                    l130.cast(),
                                                    len132,
                                                    len132,
                                                );
                                                _rt::string_lift(bytes132)
                                            };
                                            Numbound::Excluded(e133)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            Numbound::Unbounded
                                        }
                                    };
                                    let l134 = i32::from(*ptr0.add(20).cast::<u8>());
                                    let v141 = match l134 {
                                        0 => {
                                            let e141 = {
                                                let l135 = *ptr0.add(24).cast::<*mut u8>();
                                                let l136 = *ptr0.add(28).cast::<usize>();
                                                let len137 = l136;
                                                let bytes137 = _rt::Vec::from_raw_parts(
                                                    l135.cast(),
                                                    len137,
                                                    len137,
                                                );
                                                _rt::string_lift(bytes137)
                                            };
                                            Numbound::Included(e141)
                                        }
                                        1 => {
                                            let e141 = {
                                                let l138 = *ptr0.add(24).cast::<*mut u8>();
                                                let l139 = *ptr0.add(28).cast::<usize>();
                                                let len140 = l139;
                                                let bytes140 = _rt::Vec::from_raw_parts(
                                                    l138.cast(),
                                                    len140,
                                                    len140,
                                                );
                                                _rt::string_lift(bytes140)
                                            };
                                            Numbound::Excluded(e141)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            Numbound::Unbounded
                                        }
                                    };
                                    Numrange { start: v133, end: v141 }
                                };
                                DbValue::Numrange(e260)
                            }
                            31 => {
                                let e260 = {
                                    let l142 = i32::from(*ptr0.add(8).cast::<u8>());
                                    let v157 = match l142 {
                                        0 => {
                                            let e157 = {
                                                let l143 = *ptr0.add(12).cast::<i32>();
                                                let l144 = i32::from(*ptr0.add(16).cast::<u8>());
                                                let l145 = i32::from(*ptr0.add(17).cast::<u8>());
                                                let l146 = i32::from(*ptr0.add(20).cast::<u8>());
                                                let l147 = i32::from(*ptr0.add(21).cast::<u8>());
                                                let l148 = i32::from(*ptr0.add(22).cast::<u8>());
                                                let l149 = *ptr0.add(24).cast::<i32>();
                                                super::super::super::golem::rdbms::types::Timestamp {
                                                    date: super::super::super::golem::rdbms::types::Date {
                                                        year: l143,
                                                        month: l144 as u8,
                                                        day: l145 as u8,
                                                    },
                                                    time: super::super::super::golem::rdbms::types::Time {
                                                        hour: l146 as u8,
                                                        minute: l147 as u8,
                                                        second: l148 as u8,
                                                        nanosecond: l149 as u32,
                                                    },
                                                }
                                            };
                                            Tsbound::Included(e157)
                                        }
                                        1 => {
                                            let e157 = {
                                                let l150 = *ptr0.add(12).cast::<i32>();
                                                let l151 = i32::from(*ptr0.add(16).cast::<u8>());
                                                let l152 = i32::from(*ptr0.add(17).cast::<u8>());
                                                let l153 = i32::from(*ptr0.add(20).cast::<u8>());
                                                let l154 = i32::from(*ptr0.add(21).cast::<u8>());
                                                let l155 = i32::from(*ptr0.add(22).cast::<u8>());
                                                let l156 = *ptr0.add(24).cast::<i32>();
                                                super::super::super::golem::rdbms::types::Timestamp {
                                                    date: super::super::super::golem::rdbms::types::Date {
                                                        year: l150,
                                                        month: l151 as u8,
                                                        day: l152 as u8,
                                                    },
                                                    time: super::super::super::golem::rdbms::types::Time {
                                                        hour: l153 as u8,
                                                        minute: l154 as u8,
                                                        second: l155 as u8,
                                                        nanosecond: l156 as u32,
                                                    },
                                                }
                                            };
                                            Tsbound::Excluded(e157)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            Tsbound::Unbounded
                                        }
                                    };
                                    let l158 = i32::from(*ptr0.add(28).cast::<u8>());
                                    let v173 = match l158 {
                                        0 => {
                                            let e173 = {
                                                let l159 = *ptr0.add(32).cast::<i32>();
                                                let l160 = i32::from(*ptr0.add(36).cast::<u8>());
                                                let l161 = i32::from(*ptr0.add(37).cast::<u8>());
                                                let l162 = i32::from(*ptr0.add(40).cast::<u8>());
                                                let l163 = i32::from(*ptr0.add(41).cast::<u8>());
                                                let l164 = i32::from(*ptr0.add(42).cast::<u8>());
                                                let l165 = *ptr0.add(44).cast::<i32>();
                                                super::super::super::golem::rdbms::types::Timestamp {
                                                    date: super::super::super::golem::rdbms::types::Date {
                                                        year: l159,
                                                        month: l160 as u8,
                                                        day: l161 as u8,
                                                    },
                                                    time: super::super::super::golem::rdbms::types::Time {
                                                        hour: l162 as u8,
                                                        minute: l163 as u8,
                                                        second: l164 as u8,
                                                        nanosecond: l165 as u32,
                                                    },
                                                }
                                            };
                                            Tsbound::Included(e173)
                                        }
                                        1 => {
                                            let e173 = {
                                                let l166 = *ptr0.add(32).cast::<i32>();
                                                let l167 = i32::from(*ptr0.add(36).cast::<u8>());
                                                let l168 = i32::from(*ptr0.add(37).cast::<u8>());
                                                let l169 = i32::from(*ptr0.add(40).cast::<u8>());
                                                let l170 = i32::from(*ptr0.add(41).cast::<u8>());
                                                let l171 = i32::from(*ptr0.add(42).cast::<u8>());
                                                let l172 = *ptr0.add(44).cast::<i32>();
                                                super::super::super::golem::rdbms::types::Timestamp {
                                                    date: super::super::super::golem::rdbms::types::Date {
                                                        year: l166,
                                                        month: l167 as u8,
                                                        day: l168 as u8,
                                                    },
                                                    time: super::super::super::golem::rdbms::types::Time {
                                                        hour: l169 as u8,
                                                        minute: l170 as u8,
                                                        second: l171 as u8,
                                                        nanosecond: l172 as u32,
                                                    },
                                                }
                                            };
                                            Tsbound::Excluded(e173)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            Tsbound::Unbounded
                                        }
                                    };
                                    Tsrange { start: v157, end: v173 }
                                };
                                DbValue::Tsrange(e260)
                            }
                            32 => {
                                let e260 = {
                                    let l174 = i32::from(*ptr0.add(8).cast::<u8>());
                                    let v191 = match l174 {
                                        0 => {
                                            let e191 = {
                                                let l175 = *ptr0.add(12).cast::<i32>();
                                                let l176 = i32::from(*ptr0.add(16).cast::<u8>());
                                                let l177 = i32::from(*ptr0.add(17).cast::<u8>());
                                                let l178 = i32::from(*ptr0.add(20).cast::<u8>());
                                                let l179 = i32::from(*ptr0.add(21).cast::<u8>());
                                                let l180 = i32::from(*ptr0.add(22).cast::<u8>());
                                                let l181 = *ptr0.add(24).cast::<i32>();
                                                let l182 = *ptr0.add(28).cast::<i32>();
                                                super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: super::super::super::golem::rdbms::types::Timestamp {
                                                        date: super::super::super::golem::rdbms::types::Date {
                                                            year: l175,
                                                            month: l176 as u8,
                                                            day: l177 as u8,
                                                        },
                                                        time: super::super::super::golem::rdbms::types::Time {
                                                            hour: l178 as u8,
                                                            minute: l179 as u8,
                                                            second: l180 as u8,
                                                            nanosecond: l181 as u32,
                                                        },
                                                    },
                                                    offset: l182,
                                                }
                                            };
                                            Tstzbound::Included(e191)
                                        }
                                        1 => {
                                            let e191 = {
                                                let l183 = *ptr0.add(12).cast::<i32>();
                                                let l184 = i32::from(*ptr0.add(16).cast::<u8>());
                                                let l185 = i32::from(*ptr0.add(17).cast::<u8>());
                                                let l186 = i32::from(*ptr0.add(20).cast::<u8>());
                                                let l187 = i32::from(*ptr0.add(21).cast::<u8>());
                                                let l188 = i32::from(*ptr0.add(22).cast::<u8>());
                                                let l189 = *ptr0.add(24).cast::<i32>();
                                                let l190 = *ptr0.add(28).cast::<i32>();
                                                super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: super::super::super::golem::rdbms::types::Timestamp {
                                                        date: super::super::super::golem::rdbms::types::Date {
                                                            year: l183,
                                                            month: l184 as u8,
                                                            day: l185 as u8,
                                                        },
                                                        time: super::super::super::golem::rdbms::types::Time {
                                                            hour: l186 as u8,
                                                            minute: l187 as u8,
                                                            second: l188 as u8,
                                                            nanosecond: l189 as u32,
                                                        },
                                                    },
                                                    offset: l190,
                                                }
                                            };
                                            Tstzbound::Excluded(e191)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            Tstzbound::Unbounded
                                        }
                                    };
                                    let l192 = i32::from(*ptr0.add(32).cast::<u8>());
                                    let v209 = match l192 {
                                        0 => {
                                            let e209 = {
                                                let l193 = *ptr0.add(36).cast::<i32>();
                                                let l194 = i32::from(*ptr0.add(40).cast::<u8>());
                                                let l195 = i32::from(*ptr0.add(41).cast::<u8>());
                                                let l196 = i32::from(*ptr0.add(44).cast::<u8>());
                                                let l197 = i32::from(*ptr0.add(45).cast::<u8>());
                                                let l198 = i32::from(*ptr0.add(46).cast::<u8>());
                                                let l199 = *ptr0.add(48).cast::<i32>();
                                                let l200 = *ptr0.add(52).cast::<i32>();
                                                super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: super::super::super::golem::rdbms::types::Timestamp {
                                                        date: super::super::super::golem::rdbms::types::Date {
                                                            year: l193,
                                                            month: l194 as u8,
                                                            day: l195 as u8,
                                                        },
                                                        time: super::super::super::golem::rdbms::types::Time {
                                                            hour: l196 as u8,
                                                            minute: l197 as u8,
                                                            second: l198 as u8,
                                                            nanosecond: l199 as u32,
                                                        },
                                                    },
                                                    offset: l200,
                                                }
                                            };
                                            Tstzbound::Included(e209)
                                        }
                                        1 => {
                                            let e209 = {
                                                let l201 = *ptr0.add(36).cast::<i32>();
                                                let l202 = i32::from(*ptr0.add(40).cast::<u8>());
                                                let l203 = i32::from(*ptr0.add(41).cast::<u8>());
                                                let l204 = i32::from(*ptr0.add(44).cast::<u8>());
                                                let l205 = i32::from(*ptr0.add(45).cast::<u8>());
                                                let l206 = i32::from(*ptr0.add(46).cast::<u8>());
                                                let l207 = *ptr0.add(48).cast::<i32>();
                                                let l208 = *ptr0.add(52).cast::<i32>();
                                                super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: super::super::super::golem::rdbms::types::Timestamp {
                                                        date: super::super::super::golem::rdbms::types::Date {
                                                            year: l201,
                                                            month: l202 as u8,
                                                            day: l203 as u8,
                                                        },
                                                        time: super::super::super::golem::rdbms::types::Time {
                                                            hour: l204 as u8,
                                                            minute: l205 as u8,
                                                            second: l206 as u8,
                                                            nanosecond: l207 as u32,
                                                        },
                                                    },
                                                    offset: l208,
                                                }
                                            };
                                            Tstzbound::Excluded(e209)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            Tstzbound::Unbounded
                                        }
                                    };
                                    Tstzrange {
                                        start: v191,
                                        end: v209,
                                    }
                                };
                                DbValue::Tstzrange(e260)
                            }
                            33 => {
                                let e260 = {
                                    let l210 = i32::from(*ptr0.add(8).cast::<u8>());
                                    let v217 = match l210 {
                                        0 => {
                                            let e217 = {
                                                let l211 = *ptr0.add(12).cast::<i32>();
                                                let l212 = i32::from(*ptr0.add(16).cast::<u8>());
                                                let l213 = i32::from(*ptr0.add(17).cast::<u8>());
                                                super::super::super::golem::rdbms::types::Date {
                                                    year: l211,
                                                    month: l212 as u8,
                                                    day: l213 as u8,
                                                }
                                            };
                                            Datebound::Included(e217)
                                        }
                                        1 => {
                                            let e217 = {
                                                let l214 = *ptr0.add(12).cast::<i32>();
                                                let l215 = i32::from(*ptr0.add(16).cast::<u8>());
                                                let l216 = i32::from(*ptr0.add(17).cast::<u8>());
                                                super::super::super::golem::rdbms::types::Date {
                                                    year: l214,
                                                    month: l215 as u8,
                                                    day: l216 as u8,
                                                }
                                            };
                                            Datebound::Excluded(e217)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            Datebound::Unbounded
                                        }
                                    };
                                    let l218 = i32::from(*ptr0.add(20).cast::<u8>());
                                    let v225 = match l218 {
                                        0 => {
                                            let e225 = {
                                                let l219 = *ptr0.add(24).cast::<i32>();
                                                let l220 = i32::from(*ptr0.add(28).cast::<u8>());
                                                let l221 = i32::from(*ptr0.add(29).cast::<u8>());
                                                super::super::super::golem::rdbms::types::Date {
                                                    year: l219,
                                                    month: l220 as u8,
                                                    day: l221 as u8,
                                                }
                                            };
                                            Datebound::Included(e225)
                                        }
                                        1 => {
                                            let e225 = {
                                                let l222 = *ptr0.add(24).cast::<i32>();
                                                let l223 = i32::from(*ptr0.add(28).cast::<u8>());
                                                let l224 = i32::from(*ptr0.add(29).cast::<u8>());
                                                super::super::super::golem::rdbms::types::Date {
                                                    year: l222,
                                                    month: l223 as u8,
                                                    day: l224 as u8,
                                                }
                                            };
                                            Datebound::Excluded(e225)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            Datebound::Unbounded
                                        }
                                    };
                                    Daterange {
                                        start: v217,
                                        end: v225,
                                    }
                                };
                                DbValue::Daterange(e260)
                            }
                            34 => {
                                let e260 = {
                                    let l226 = *ptr0.add(8).cast::<i64>();
                                    l226
                                };
                                DbValue::Money(e260)
                            }
                            35 => {
                                let e260 = {
                                    let l227 = *ptr0.add(8).cast::<i32>();
                                    l227 as u32
                                };
                                DbValue::Oid(e260)
                            }
                            36 => {
                                let e260 = {
                                    let l228 = *ptr0.add(8).cast::<*mut u8>();
                                    let l229 = *ptr0.add(12).cast::<usize>();
                                    let len230 = l229;
                                    let bytes230 = _rt::Vec::from_raw_parts(
                                        l228.cast(),
                                        len230,
                                        len230,
                                    );
                                    let l231 = *ptr0.add(16).cast::<*mut u8>();
                                    let l232 = *ptr0.add(20).cast::<usize>();
                                    let len233 = l232;
                                    let bytes233 = _rt::Vec::from_raw_parts(
                                        l231.cast(),
                                        len233,
                                        len233,
                                    );
                                    Enumeration {
                                        name: _rt::string_lift(bytes230),
                                        value: _rt::string_lift(bytes233),
                                    }
                                };
                                DbValue::Enumeration(e260)
                            }
                            37 => {
                                let e260 = {
                                    let l234 = *ptr0.add(8).cast::<*mut u8>();
                                    let l235 = *ptr0.add(12).cast::<usize>();
                                    let len236 = l235;
                                    let bytes236 = _rt::Vec::from_raw_parts(
                                        l234.cast(),
                                        len236,
                                        len236,
                                    );
                                    let l237 = *ptr0.add(16).cast::<*mut u8>();
                                    let l238 = *ptr0.add(20).cast::<usize>();
                                    let base240 = l237;
                                    let len240 = l238;
                                    let mut result240 = _rt::Vec::with_capacity(len240);
                                    for i in 0..len240 {
                                        let base = base240.add(i * 4);
                                        let e240 = {
                                            let l239 = *base.add(0).cast::<i32>();
                                            LazyDbValue::from_handle(l239 as u32)
                                        };
                                        result240.push(e240);
                                    }
                                    _rt::cabi_dealloc(base240, len240 * 4, 4);
                                    Composite {
                                        name: _rt::string_lift(bytes236),
                                        values: result240,
                                    }
                                };
                                DbValue::Composite(e260)
                            }
                            38 => {
                                let e260 = {
                                    let l241 = *ptr0.add(8).cast::<*mut u8>();
                                    let l242 = *ptr0.add(12).cast::<usize>();
                                    let len243 = l242;
                                    let bytes243 = _rt::Vec::from_raw_parts(
                                        l241.cast(),
                                        len243,
                                        len243,
                                    );
                                    let l244 = *ptr0.add(16).cast::<i32>();
                                    Domain {
                                        name: _rt::string_lift(bytes243),
                                        value: LazyDbValue::from_handle(l244 as u32),
                                    }
                                };
                                DbValue::Domain(e260)
                            }
                            39 => {
                                let e260 = {
                                    let l245 = *ptr0.add(8).cast::<*mut u8>();
                                    let l246 = *ptr0.add(12).cast::<usize>();
                                    let base248 = l245;
                                    let len248 = l246;
                                    let mut result248 = _rt::Vec::with_capacity(len248);
                                    for i in 0..len248 {
                                        let base = base248.add(i * 4);
                                        let e248 = {
                                            let l247 = *base.add(0).cast::<i32>();
                                            LazyDbValue::from_handle(l247 as u32)
                                        };
                                        result248.push(e248);
                                    }
                                    _rt::cabi_dealloc(base248, len248 * 4, 4);
                                    result248
                                };
                                DbValue::Array(e260)
                            }
                            40 => {
                                let e260 = {
                                    let l249 = *ptr0.add(8).cast::<*mut u8>();
                                    let l250 = *ptr0.add(12).cast::<usize>();
                                    let len251 = l250;
                                    let bytes251 = _rt::Vec::from_raw_parts(
                                        l249.cast(),
                                        len251,
                                        len251,
                                    );
                                    let l252 = i32::from(*ptr0.add(16).cast::<u8>());
                                    let v255 = match l252 {
                                        0 => {
                                            let e255 = {
                                                let l253 = *ptr0.add(20).cast::<i32>();
                                                LazyDbValue::from_handle(l253 as u32)
                                            };
                                            ValueBound::Included(e255)
                                        }
                                        1 => {
                                            let e255 = {
                                                let l254 = *ptr0.add(20).cast::<i32>();
                                                LazyDbValue::from_handle(l254 as u32)
                                            };
                                            ValueBound::Excluded(e255)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            ValueBound::Unbounded
                                        }
                                    };
                                    let l256 = i32::from(*ptr0.add(24).cast::<u8>());
                                    let v259 = match l256 {
                                        0 => {
                                            let e259 = {
                                                let l257 = *ptr0.add(28).cast::<i32>();
                                                LazyDbValue::from_handle(l257 as u32)
                                            };
                                            ValueBound::Included(e259)
                                        }
                                        1 => {
                                            let e259 = {
                                                let l258 = *ptr0.add(28).cast::<i32>();
                                                LazyDbValue::from_handle(l258 as u32)
                                            };
                                            ValueBound::Excluded(e259)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            ValueBound::Unbounded
                                        }
                                    };
                                    Range {
                                        name: _rt::string_lift(bytes251),
                                        value: ValuesRange {
                                            start: v255,
                                            end: v259,
                                        },
                                    }
                                };
                                DbValue::Range(e260)
                            }
                            n => {
                                debug_assert_eq!(n, 41, "invalid enum discriminant");
                                DbValue::Null
                            }
                        };
                        v260
                    }
                }
            }
            impl LazyDbColumnType {
                #[allow(unused_unsafe, clippy::all)]
                pub fn new(value: DbColumnType) -> Self {
                    unsafe {
                        let mut cleanup_list = _rt::Vec::new();
                        let (
                            result11_0,
                            result11_1,
                            result11_2,
                            result11_3,
                            result11_4,
                        ) = match &value {
                            DbColumnType::Character => {
                                (
                                    0i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Int2 => {
                                (
                                    1i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Int4 => {
                                (
                                    2i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Int8 => {
                                (
                                    3i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Float4 => {
                                (
                                    4i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Float8 => {
                                (
                                    5i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Numeric => {
                                (
                                    6i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Boolean => {
                                (
                                    7i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Text => {
                                (
                                    8i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Varchar => {
                                (
                                    9i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Bpchar => {
                                (
                                    10i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Timestamp => {
                                (
                                    11i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Timestamptz => {
                                (
                                    12i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Date => {
                                (
                                    13i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Time => {
                                (
                                    14i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Timetz => {
                                (
                                    15i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Interval => {
                                (
                                    16i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Bytea => {
                                (
                                    17i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Uuid => {
                                (
                                    18i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Xml => {
                                (
                                    19i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Json => {
                                (
                                    20i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Jsonb => {
                                (
                                    21i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Jsonpath => {
                                (
                                    22i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Inet => {
                                (
                                    23i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Cidr => {
                                (
                                    24i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Macaddr => {
                                (
                                    25i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Bit => {
                                (
                                    26i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Varbit => {
                                (
                                    27i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Int4range => {
                                (
                                    28i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Int8range => {
                                (
                                    29i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Numrange => {
                                (
                                    30i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Tsrange => {
                                (
                                    31i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Tstzrange => {
                                (
                                    32i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Daterange => {
                                (
                                    33i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Money => {
                                (
                                    34i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Oid => {
                                (
                                    35i32,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Enumeration(e) => {
                                let EnumerationType { name: name0 } = e;
                                let vec1 = name0;
                                let ptr1 = vec1.as_ptr().cast::<u8>();
                                let len1 = vec1.len();
                                (
                                    36i32,
                                    ptr1.cast_mut(),
                                    len1,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Composite(e) => {
                                let CompositeType {
                                    name: name2,
                                    attributes: attributes2,
                                } = e;
                                let vec3 = name2;
                                let ptr3 = vec3.as_ptr().cast::<u8>();
                                let len3 = vec3.len();
                                let vec6 = attributes2;
                                let len6 = vec6.len();
                                let layout6 = _rt::alloc::Layout::from_size_align_unchecked(
                                    vec6.len() * 12,
                                    4,
                                );
                                let result6 = if layout6.size() != 0 {
                                    let ptr = _rt::alloc::alloc(layout6).cast::<u8>();
                                    if ptr.is_null() {
                                        _rt::alloc::handle_alloc_error(layout6);
                                    }
                                    ptr
                                } else {
                                    ::core::ptr::null_mut()
                                };
                                for (i, e) in vec6.into_iter().enumerate() {
                                    let base = result6.add(i * 12);
                                    {
                                        let (t4_0, t4_1) = e;
                                        let vec5 = t4_0;
                                        let ptr5 = vec5.as_ptr().cast::<u8>();
                                        let len5 = vec5.len();
                                        *base.add(4).cast::<usize>() = len5;
                                        *base.add(0).cast::<*mut u8>() = ptr5.cast_mut();
                                        *base.add(8).cast::<i32>() = (t4_1).take_handle() as i32;
                                    }
                                }
                                cleanup_list.extend_from_slice(&[(result6, layout6)]);
                                (37i32, ptr3.cast_mut(), len3, result6, len6)
                            }
                            DbColumnType::Domain(e) => {
                                let DomainType { name: name7, base_type: base_type7 } = e;
                                let vec8 = name7;
                                let ptr8 = vec8.as_ptr().cast::<u8>();
                                let len8 = vec8.len();
                                (
                                    38i32,
                                    ptr8.cast_mut(),
                                    len8,
                                    (base_type7).take_handle() as i32 as *mut u8,
                                    0usize,
                                )
                            }
                            DbColumnType::Array(e) => {
                                (
                                    39i32,
                                    (e).take_handle() as i32 as *mut u8,
                                    0usize,
                                    ::core::ptr::null_mut(),
                                    0usize,
                                )
                            }
                            DbColumnType::Range(e) => {
                                let RangeType { name: name9, base_type: base_type9 } = e;
                                let vec10 = name9;
                                let ptr10 = vec10.as_ptr().cast::<u8>();
                                let len10 = vec10.len();
                                (
                                    40i32,
                                    ptr10.cast_mut(),
                                    len10,
                                    (base_type9).take_handle() as i32 as *mut u8,
                                    0usize,
                                )
                            }
                        };
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rdbms/postgres@0.0.1")]
                        extern "C" {
                            #[link_name = "[constructor]lazy-db-column-type"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                            ) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                        ) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import(
                            result11_0,
                            result11_1,
                            result11_2,
                            result11_3,
                            result11_4,
                        );
                        for (ptr, layout) in cleanup_list {
                            if layout.size() != 0 {
                                _rt::alloc::dealloc(ptr.cast(), layout);
                            }
                        }
                        LazyDbColumnType::from_handle(ret as u32)
                    }
                }
            }
            impl LazyDbColumnType {
                #[allow(unused_unsafe, clippy::all)]
                pub fn get(&self) -> DbColumnType {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 20]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 20],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rdbms/postgres@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]lazy-db-column-type.get"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        let v24 = match l1 {
                            0 => DbColumnType::Character,
                            1 => DbColumnType::Int2,
                            2 => DbColumnType::Int4,
                            3 => DbColumnType::Int8,
                            4 => DbColumnType::Float4,
                            5 => DbColumnType::Float8,
                            6 => DbColumnType::Numeric,
                            7 => DbColumnType::Boolean,
                            8 => DbColumnType::Text,
                            9 => DbColumnType::Varchar,
                            10 => DbColumnType::Bpchar,
                            11 => DbColumnType::Timestamp,
                            12 => DbColumnType::Timestamptz,
                            13 => DbColumnType::Date,
                            14 => DbColumnType::Time,
                            15 => DbColumnType::Timetz,
                            16 => DbColumnType::Interval,
                            17 => DbColumnType::Bytea,
                            18 => DbColumnType::Uuid,
                            19 => DbColumnType::Xml,
                            20 => DbColumnType::Json,
                            21 => DbColumnType::Jsonb,
                            22 => DbColumnType::Jsonpath,
                            23 => DbColumnType::Inet,
                            24 => DbColumnType::Cidr,
                            25 => DbColumnType::Macaddr,
                            26 => DbColumnType::Bit,
                            27 => DbColumnType::Varbit,
                            28 => DbColumnType::Int4range,
                            29 => DbColumnType::Int8range,
                            30 => DbColumnType::Numrange,
                            31 => DbColumnType::Tsrange,
                            32 => DbColumnType::Tstzrange,
                            33 => DbColumnType::Daterange,
                            34 => DbColumnType::Money,
                            35 => DbColumnType::Oid,
                            36 => {
                                let e24 = {
                                    let l2 = *ptr0.add(4).cast::<*mut u8>();
                                    let l3 = *ptr0.add(8).cast::<usize>();
                                    let len4 = l3;
                                    let bytes4 = _rt::Vec::from_raw_parts(
                                        l2.cast(),
                                        len4,
                                        len4,
                                    );
                                    EnumerationType {
                                        name: _rt::string_lift(bytes4),
                                    }
                                };
                                DbColumnType::Enumeration(e24)
                            }
                            37 => {
                                let e24 = {
                                    let l5 = *ptr0.add(4).cast::<*mut u8>();
                                    let l6 = *ptr0.add(8).cast::<usize>();
                                    let len7 = l6;
                                    let bytes7 = _rt::Vec::from_raw_parts(
                                        l5.cast(),
                                        len7,
                                        len7,
                                    );
                                    let l8 = *ptr0.add(12).cast::<*mut u8>();
                                    let l9 = *ptr0.add(16).cast::<usize>();
                                    let base14 = l8;
                                    let len14 = l9;
                                    let mut result14 = _rt::Vec::with_capacity(len14);
                                    for i in 0..len14 {
                                        let base = base14.add(i * 12);
                                        let e14 = {
                                            let l10 = *base.add(0).cast::<*mut u8>();
                                            let l11 = *base.add(4).cast::<usize>();
                                            let len12 = l11;
                                            let bytes12 = _rt::Vec::from_raw_parts(
                                                l10.cast(),
                                                len12,
                                                len12,
                                            );
                                            let l13 = *base.add(8).cast::<i32>();
                                            (
                                                _rt::string_lift(bytes12),
                                                LazyDbColumnType::from_handle(l13 as u32),
                                            )
                                        };
                                        result14.push(e14);
                                    }
                                    _rt::cabi_dealloc(base14, len14 * 12, 4);
                                    CompositeType {
                                        name: _rt::string_lift(bytes7),
                                        attributes: result14,
                                    }
                                };
                                DbColumnType::Composite(e24)
                            }
                            38 => {
                                let e24 = {
                                    let l15 = *ptr0.add(4).cast::<*mut u8>();
                                    let l16 = *ptr0.add(8).cast::<usize>();
                                    let len17 = l16;
                                    let bytes17 = _rt::Vec::from_raw_parts(
                                        l15.cast(),
                                        len17,
                                        len17,
                                    );
                                    let l18 = *ptr0.add(12).cast::<i32>();
                                    DomainType {
                                        name: _rt::string_lift(bytes17),
                                        base_type: LazyDbColumnType::from_handle(l18 as u32),
                                    }
                                };
                                DbColumnType::Domain(e24)
                            }
                            39 => {
                                let e24 = {
                                    let l19 = *ptr0.add(4).cast::<i32>();
                                    LazyDbColumnType::from_handle(l19 as u32)
                                };
                                DbColumnType::Array(e24)
                            }
                            n => {
                                debug_assert_eq!(n, 40, "invalid enum discriminant");
                                let e24 = {
                                    let l20 = *ptr0.add(4).cast::<*mut u8>();
                                    let l21 = *ptr0.add(8).cast::<usize>();
                                    let len22 = l21;
                                    let bytes22 = _rt::Vec::from_raw_parts(
                                        l20.cast(),
                                        len22,
                                        len22,
                                    );
                                    let l23 = *ptr0.add(12).cast::<i32>();
                                    RangeType {
                                        name: _rt::string_lift(bytes22),
                                        base_type: LazyDbColumnType::from_handle(l23 as u32),
                                    }
                                };
                                DbColumnType::Range(e24)
                            }
                        };
                        v24
                    }
                }
            }
            impl DbResultStream {
                #[allow(unused_unsafe, clippy::all)]
                pub fn get_columns(&self) -> _rt::Vec<DbColumn> {
                    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 = "golem:rdbms/postgres@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-result-stream.get-columns"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = *ptr0.add(0).cast::<*mut u8>();
                        let l2 = *ptr0.add(4).cast::<usize>();
                        let base34 = l1;
                        let len34 = l2;
                        let mut result34 = _rt::Vec::with_capacity(len34);
                        for i in 0..len34 {
                            let base = base34.add(i * 48);
                            let e34 = {
                                let l3 = *base.add(0).cast::<i64>();
                                let l4 = *base.add(8).cast::<*mut u8>();
                                let l5 = *base.add(12).cast::<usize>();
                                let len6 = l5;
                                let bytes6 = _rt::Vec::from_raw_parts(
                                    l4.cast(),
                                    len6,
                                    len6,
                                );
                                let l7 = i32::from(*base.add(16).cast::<u8>());
                                let v30 = match l7 {
                                    0 => DbColumnType::Character,
                                    1 => DbColumnType::Int2,
                                    2 => DbColumnType::Int4,
                                    3 => DbColumnType::Int8,
                                    4 => DbColumnType::Float4,
                                    5 => DbColumnType::Float8,
                                    6 => DbColumnType::Numeric,
                                    7 => DbColumnType::Boolean,
                                    8 => DbColumnType::Text,
                                    9 => DbColumnType::Varchar,
                                    10 => DbColumnType::Bpchar,
                                    11 => DbColumnType::Timestamp,
                                    12 => DbColumnType::Timestamptz,
                                    13 => DbColumnType::Date,
                                    14 => DbColumnType::Time,
                                    15 => DbColumnType::Timetz,
                                    16 => DbColumnType::Interval,
                                    17 => DbColumnType::Bytea,
                                    18 => DbColumnType::Uuid,
                                    19 => DbColumnType::Xml,
                                    20 => DbColumnType::Json,
                                    21 => DbColumnType::Jsonb,
                                    22 => DbColumnType::Jsonpath,
                                    23 => DbColumnType::Inet,
                                    24 => DbColumnType::Cidr,
                                    25 => DbColumnType::Macaddr,
                                    26 => DbColumnType::Bit,
                                    27 => DbColumnType::Varbit,
                                    28 => DbColumnType::Int4range,
                                    29 => DbColumnType::Int8range,
                                    30 => DbColumnType::Numrange,
                                    31 => DbColumnType::Tsrange,
                                    32 => DbColumnType::Tstzrange,
                                    33 => DbColumnType::Daterange,
                                    34 => DbColumnType::Money,
                                    35 => DbColumnType::Oid,
                                    36 => {
                                        let e30 = {
                                            let l8 = *base.add(20).cast::<*mut u8>();
                                            let l9 = *base.add(24).cast::<usize>();
                                            let len10 = l9;
                                            let bytes10 = _rt::Vec::from_raw_parts(
                                                l8.cast(),
                                                len10,
                                                len10,
                                            );
                                            EnumerationType {
                                                name: _rt::string_lift(bytes10),
                                            }
                                        };
                                        DbColumnType::Enumeration(e30)
                                    }
                                    37 => {
                                        let e30 = {
                                            let l11 = *base.add(20).cast::<*mut u8>();
                                            let l12 = *base.add(24).cast::<usize>();
                                            let len13 = l12;
                                            let bytes13 = _rt::Vec::from_raw_parts(
                                                l11.cast(),
                                                len13,
                                                len13,
                                            );
                                            let l14 = *base.add(28).cast::<*mut u8>();
                                            let l15 = *base.add(32).cast::<usize>();
                                            let base20 = l14;
                                            let len20 = l15;
                                            let mut result20 = _rt::Vec::with_capacity(len20);
                                            for i in 0..len20 {
                                                let base = base20.add(i * 12);
                                                let e20 = {
                                                    let l16 = *base.add(0).cast::<*mut u8>();
                                                    let l17 = *base.add(4).cast::<usize>();
                                                    let len18 = l17;
                                                    let bytes18 = _rt::Vec::from_raw_parts(
                                                        l16.cast(),
                                                        len18,
                                                        len18,
                                                    );
                                                    let l19 = *base.add(8).cast::<i32>();
                                                    (
                                                        _rt::string_lift(bytes18),
                                                        LazyDbColumnType::from_handle(l19 as u32),
                                                    )
                                                };
                                                result20.push(e20);
                                            }
                                            _rt::cabi_dealloc(base20, len20 * 12, 4);
                                            CompositeType {
                                                name: _rt::string_lift(bytes13),
                                                attributes: result20,
                                            }
                                        };
                                        DbColumnType::Composite(e30)
                                    }
                                    38 => {
                                        let e30 = {
                                            let l21 = *base.add(20).cast::<*mut u8>();
                                            let l22 = *base.add(24).cast::<usize>();
                                            let len23 = l22;
                                            let bytes23 = _rt::Vec::from_raw_parts(
                                                l21.cast(),
                                                len23,
                                                len23,
                                            );
                                            let l24 = *base.add(28).cast::<i32>();
                                            DomainType {
                                                name: _rt::string_lift(bytes23),
                                                base_type: LazyDbColumnType::from_handle(l24 as u32),
                                            }
                                        };
                                        DbColumnType::Domain(e30)
                                    }
                                    39 => {
                                        let e30 = {
                                            let l25 = *base.add(20).cast::<i32>();
                                            LazyDbColumnType::from_handle(l25 as u32)
                                        };
                                        DbColumnType::Array(e30)
                                    }
                                    n => {
                                        debug_assert_eq!(n, 40, "invalid enum discriminant");
                                        let e30 = {
                                            let l26 = *base.add(20).cast::<*mut u8>();
                                            let l27 = *base.add(24).cast::<usize>();
                                            let len28 = l27;
                                            let bytes28 = _rt::Vec::from_raw_parts(
                                                l26.cast(),
                                                len28,
                                                len28,
                                            );
                                            let l29 = *base.add(28).cast::<i32>();
                                            RangeType {
                                                name: _rt::string_lift(bytes28),
                                                base_type: LazyDbColumnType::from_handle(l29 as u32),
                                            }
                                        };
                                        DbColumnType::Range(e30)
                                    }
                                };
                                let l31 = *base.add(36).cast::<*mut u8>();
                                let l32 = *base.add(40).cast::<usize>();
                                let len33 = l32;
                                let bytes33 = _rt::Vec::from_raw_parts(
                                    l31.cast(),
                                    len33,
                                    len33,
                                );
                                DbColumn {
                                    ordinal: l3 as u64,
                                    name: _rt::string_lift(bytes6),
                                    db_type: v30,
                                    db_type_name: _rt::string_lift(bytes33),
                                }
                            };
                            result34.push(e34);
                        }
                        _rt::cabi_dealloc(base34, len34 * 48, 8);
                        result34
                    }
                }
            }
            impl DbResultStream {
                #[allow(unused_unsafe, clippy::all)]
                pub fn get_next(&self) -> Option<_rt::Vec<DbRow>> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rdbms/postgres@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-result-stream.get-next"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<*mut u8>();
                                    let l3 = *ptr0.add(8).cast::<usize>();
                                    let base267 = l2;
                                    let len267 = l3;
                                    let mut result267 = _rt::Vec::with_capacity(len267);
                                    for i in 0..len267 {
                                        let base = base267.add(i * 8);
                                        let e267 = {
                                            let l4 = *base.add(0).cast::<*mut u8>();
                                            let l5 = *base.add(4).cast::<usize>();
                                            let base266 = l4;
                                            let len266 = l5;
                                            let mut result266 = _rt::Vec::with_capacity(len266);
                                            for i in 0..len266 {
                                                let base = base266.add(i * 56);
                                                let e266 = {
                                                    let l6 = i32::from(*base.add(0).cast::<u8>());
                                                    let v265 = match l6 {
                                                        0 => {
                                                            let e265 = {
                                                                let l7 = i32::from(*base.add(8).cast::<i8>());
                                                                l7 as i8
                                                            };
                                                            DbValue::Character(e265)
                                                        }
                                                        1 => {
                                                            let e265 = {
                                                                let l8 = i32::from(*base.add(8).cast::<i16>());
                                                                l8 as i16
                                                            };
                                                            DbValue::Int2(e265)
                                                        }
                                                        2 => {
                                                            let e265 = {
                                                                let l9 = *base.add(8).cast::<i32>();
                                                                l9
                                                            };
                                                            DbValue::Int4(e265)
                                                        }
                                                        3 => {
                                                            let e265 = {
                                                                let l10 = *base.add(8).cast::<i64>();
                                                                l10
                                                            };
                                                            DbValue::Int8(e265)
                                                        }
                                                        4 => {
                                                            let e265 = {
                                                                let l11 = *base.add(8).cast::<f32>();
                                                                l11
                                                            };
                                                            DbValue::Float4(e265)
                                                        }
                                                        5 => {
                                                            let e265 = {
                                                                let l12 = *base.add(8).cast::<f64>();
                                                                l12
                                                            };
                                                            DbValue::Float8(e265)
                                                        }
                                                        6 => {
                                                            let e265 = {
                                                                let l13 = *base.add(8).cast::<*mut u8>();
                                                                let l14 = *base.add(12).cast::<usize>();
                                                                let len15 = l14;
                                                                let bytes15 = _rt::Vec::from_raw_parts(
                                                                    l13.cast(),
                                                                    len15,
                                                                    len15,
                                                                );
                                                                _rt::string_lift(bytes15)
                                                            };
                                                            DbValue::Numeric(e265)
                                                        }
                                                        7 => {
                                                            let e265 = {
                                                                let l16 = i32::from(*base.add(8).cast::<u8>());
                                                                _rt::bool_lift(l16 as u8)
                                                            };
                                                            DbValue::Boolean(e265)
                                                        }
                                                        8 => {
                                                            let e265 = {
                                                                let l17 = *base.add(8).cast::<*mut u8>();
                                                                let l18 = *base.add(12).cast::<usize>();
                                                                let len19 = l18;
                                                                let bytes19 = _rt::Vec::from_raw_parts(
                                                                    l17.cast(),
                                                                    len19,
                                                                    len19,
                                                                );
                                                                _rt::string_lift(bytes19)
                                                            };
                                                            DbValue::Text(e265)
                                                        }
                                                        9 => {
                                                            let e265 = {
                                                                let l20 = *base.add(8).cast::<*mut u8>();
                                                                let l21 = *base.add(12).cast::<usize>();
                                                                let len22 = l21;
                                                                let bytes22 = _rt::Vec::from_raw_parts(
                                                                    l20.cast(),
                                                                    len22,
                                                                    len22,
                                                                );
                                                                _rt::string_lift(bytes22)
                                                            };
                                                            DbValue::Varchar(e265)
                                                        }
                                                        10 => {
                                                            let e265 = {
                                                                let l23 = *base.add(8).cast::<*mut u8>();
                                                                let l24 = *base.add(12).cast::<usize>();
                                                                let len25 = l24;
                                                                let bytes25 = _rt::Vec::from_raw_parts(
                                                                    l23.cast(),
                                                                    len25,
                                                                    len25,
                                                                );
                                                                _rt::string_lift(bytes25)
                                                            };
                                                            DbValue::Bpchar(e265)
                                                        }
                                                        11 => {
                                                            let e265 = {
                                                                let l26 = *base.add(8).cast::<i32>();
                                                                let l27 = i32::from(*base.add(12).cast::<u8>());
                                                                let l28 = i32::from(*base.add(13).cast::<u8>());
                                                                let l29 = i32::from(*base.add(16).cast::<u8>());
                                                                let l30 = i32::from(*base.add(17).cast::<u8>());
                                                                let l31 = i32::from(*base.add(18).cast::<u8>());
                                                                let l32 = *base.add(20).cast::<i32>();
                                                                super::super::super::golem::rdbms::types::Timestamp {
                                                                    date: super::super::super::golem::rdbms::types::Date {
                                                                        year: l26,
                                                                        month: l27 as u8,
                                                                        day: l28 as u8,
                                                                    },
                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                        hour: l29 as u8,
                                                                        minute: l30 as u8,
                                                                        second: l31 as u8,
                                                                        nanosecond: l32 as u32,
                                                                    },
                                                                }
                                                            };
                                                            DbValue::Timestamp(e265)
                                                        }
                                                        12 => {
                                                            let e265 = {
                                                                let l33 = *base.add(8).cast::<i32>();
                                                                let l34 = i32::from(*base.add(12).cast::<u8>());
                                                                let l35 = i32::from(*base.add(13).cast::<u8>());
                                                                let l36 = i32::from(*base.add(16).cast::<u8>());
                                                                let l37 = i32::from(*base.add(17).cast::<u8>());
                                                                let l38 = i32::from(*base.add(18).cast::<u8>());
                                                                let l39 = *base.add(20).cast::<i32>();
                                                                let l40 = *base.add(24).cast::<i32>();
                                                                super::super::super::golem::rdbms::types::Timestamptz {
                                                                    timestamp: super::super::super::golem::rdbms::types::Timestamp {
                                                                        date: super::super::super::golem::rdbms::types::Date {
                                                                            year: l33,
                                                                            month: l34 as u8,
                                                                            day: l35 as u8,
                                                                        },
                                                                        time: super::super::super::golem::rdbms::types::Time {
                                                                            hour: l36 as u8,
                                                                            minute: l37 as u8,
                                                                            second: l38 as u8,
                                                                            nanosecond: l39 as u32,
                                                                        },
                                                                    },
                                                                    offset: l40,
                                                                }
                                                            };
                                                            DbValue::Timestamptz(e265)
                                                        }
                                                        13 => {
                                                            let e265 = {
                                                                let l41 = *base.add(8).cast::<i32>();
                                                                let l42 = i32::from(*base.add(12).cast::<u8>());
                                                                let l43 = i32::from(*base.add(13).cast::<u8>());
                                                                super::super::super::golem::rdbms::types::Date {
                                                                    year: l41,
                                                                    month: l42 as u8,
                                                                    day: l43 as u8,
                                                                }
                                                            };
                                                            DbValue::Date(e265)
                                                        }
                                                        14 => {
                                                            let e265 = {
                                                                let l44 = i32::from(*base.add(8).cast::<u8>());
                                                                let l45 = i32::from(*base.add(9).cast::<u8>());
                                                                let l46 = i32::from(*base.add(10).cast::<u8>());
                                                                let l47 = *base.add(12).cast::<i32>();
                                                                super::super::super::golem::rdbms::types::Time {
                                                                    hour: l44 as u8,
                                                                    minute: l45 as u8,
                                                                    second: l46 as u8,
                                                                    nanosecond: l47 as u32,
                                                                }
                                                            };
                                                            DbValue::Time(e265)
                                                        }
                                                        15 => {
                                                            let e265 = {
                                                                let l48 = i32::from(*base.add(8).cast::<u8>());
                                                                let l49 = i32::from(*base.add(9).cast::<u8>());
                                                                let l50 = i32::from(*base.add(10).cast::<u8>());
                                                                let l51 = *base.add(12).cast::<i32>();
                                                                let l52 = *base.add(16).cast::<i32>();
                                                                super::super::super::golem::rdbms::types::Timetz {
                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                        hour: l48 as u8,
                                                                        minute: l49 as u8,
                                                                        second: l50 as u8,
                                                                        nanosecond: l51 as u32,
                                                                    },
                                                                    offset: l52,
                                                                }
                                                            };
                                                            DbValue::Timetz(e265)
                                                        }
                                                        16 => {
                                                            let e265 = {
                                                                let l53 = *base.add(8).cast::<i32>();
                                                                let l54 = *base.add(12).cast::<i32>();
                                                                let l55 = *base.add(16).cast::<i64>();
                                                                Interval {
                                                                    months: l53,
                                                                    days: l54,
                                                                    microseconds: l55,
                                                                }
                                                            };
                                                            DbValue::Interval(e265)
                                                        }
                                                        17 => {
                                                            let e265 = {
                                                                let l56 = *base.add(8).cast::<*mut u8>();
                                                                let l57 = *base.add(12).cast::<usize>();
                                                                let len58 = l57;
                                                                _rt::Vec::from_raw_parts(l56.cast(), len58, len58)
                                                            };
                                                            DbValue::Bytea(e265)
                                                        }
                                                        18 => {
                                                            let e265 = {
                                                                let l59 = *base.add(8).cast::<*mut u8>();
                                                                let l60 = *base.add(12).cast::<usize>();
                                                                let len61 = l60;
                                                                let bytes61 = _rt::Vec::from_raw_parts(
                                                                    l59.cast(),
                                                                    len61,
                                                                    len61,
                                                                );
                                                                _rt::string_lift(bytes61)
                                                            };
                                                            DbValue::Json(e265)
                                                        }
                                                        19 => {
                                                            let e265 = {
                                                                let l62 = *base.add(8).cast::<*mut u8>();
                                                                let l63 = *base.add(12).cast::<usize>();
                                                                let len64 = l63;
                                                                let bytes64 = _rt::Vec::from_raw_parts(
                                                                    l62.cast(),
                                                                    len64,
                                                                    len64,
                                                                );
                                                                _rt::string_lift(bytes64)
                                                            };
                                                            DbValue::Jsonb(e265)
                                                        }
                                                        20 => {
                                                            let e265 = {
                                                                let l65 = *base.add(8).cast::<*mut u8>();
                                                                let l66 = *base.add(12).cast::<usize>();
                                                                let len67 = l66;
                                                                let bytes67 = _rt::Vec::from_raw_parts(
                                                                    l65.cast(),
                                                                    len67,
                                                                    len67,
                                                                );
                                                                _rt::string_lift(bytes67)
                                                            };
                                                            DbValue::Jsonpath(e265)
                                                        }
                                                        21 => {
                                                            let e265 = {
                                                                let l68 = *base.add(8).cast::<*mut u8>();
                                                                let l69 = *base.add(12).cast::<usize>();
                                                                let len70 = l69;
                                                                let bytes70 = _rt::Vec::from_raw_parts(
                                                                    l68.cast(),
                                                                    len70,
                                                                    len70,
                                                                );
                                                                _rt::string_lift(bytes70)
                                                            };
                                                            DbValue::Xml(e265)
                                                        }
                                                        22 => {
                                                            let e265 = {
                                                                let l71 = *base.add(8).cast::<i64>();
                                                                let l72 = *base.add(16).cast::<i64>();
                                                                super::super::super::golem::rdbms::types::Uuid {
                                                                    high_bits: l71 as u64,
                                                                    low_bits: l72 as u64,
                                                                }
                                                            };
                                                            DbValue::Uuid(e265)
                                                        }
                                                        23 => {
                                                            let e265 = {
                                                                let l73 = i32::from(*base.add(8).cast::<u8>());
                                                                use super::super::super::golem::rdbms::types::IpAddress as V86;
                                                                let v86 = match l73 {
                                                                    0 => {
                                                                        let e86 = {
                                                                            let l74 = i32::from(*base.add(10).cast::<u8>());
                                                                            let l75 = i32::from(*base.add(11).cast::<u8>());
                                                                            let l76 = i32::from(*base.add(12).cast::<u8>());
                                                                            let l77 = i32::from(*base.add(13).cast::<u8>());
                                                                            (l74 as u8, l75 as u8, l76 as u8, l77 as u8)
                                                                        };
                                                                        V86::Ipv4(e86)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 1, "invalid enum discriminant");
                                                                        let e86 = {
                                                                            let l78 = i32::from(*base.add(10).cast::<u16>());
                                                                            let l79 = i32::from(*base.add(12).cast::<u16>());
                                                                            let l80 = i32::from(*base.add(14).cast::<u16>());
                                                                            let l81 = i32::from(*base.add(16).cast::<u16>());
                                                                            let l82 = i32::from(*base.add(18).cast::<u16>());
                                                                            let l83 = i32::from(*base.add(20).cast::<u16>());
                                                                            let l84 = i32::from(*base.add(22).cast::<u16>());
                                                                            let l85 = i32::from(*base.add(24).cast::<u16>());
                                                                            (
                                                                                l78 as u16,
                                                                                l79 as u16,
                                                                                l80 as u16,
                                                                                l81 as u16,
                                                                                l82 as u16,
                                                                                l83 as u16,
                                                                                l84 as u16,
                                                                                l85 as u16,
                                                                            )
                                                                        };
                                                                        V86::Ipv6(e86)
                                                                    }
                                                                };
                                                                v86
                                                            };
                                                            DbValue::Inet(e265)
                                                        }
                                                        24 => {
                                                            let e265 = {
                                                                let l87 = i32::from(*base.add(8).cast::<u8>());
                                                                use super::super::super::golem::rdbms::types::IpAddress as V100;
                                                                let v100 = match l87 {
                                                                    0 => {
                                                                        let e100 = {
                                                                            let l88 = i32::from(*base.add(10).cast::<u8>());
                                                                            let l89 = i32::from(*base.add(11).cast::<u8>());
                                                                            let l90 = i32::from(*base.add(12).cast::<u8>());
                                                                            let l91 = i32::from(*base.add(13).cast::<u8>());
                                                                            (l88 as u8, l89 as u8, l90 as u8, l91 as u8)
                                                                        };
                                                                        V100::Ipv4(e100)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 1, "invalid enum discriminant");
                                                                        let e100 = {
                                                                            let l92 = i32::from(*base.add(10).cast::<u16>());
                                                                            let l93 = i32::from(*base.add(12).cast::<u16>());
                                                                            let l94 = i32::from(*base.add(14).cast::<u16>());
                                                                            let l95 = i32::from(*base.add(16).cast::<u16>());
                                                                            let l96 = i32::from(*base.add(18).cast::<u16>());
                                                                            let l97 = i32::from(*base.add(20).cast::<u16>());
                                                                            let l98 = i32::from(*base.add(22).cast::<u16>());
                                                                            let l99 = i32::from(*base.add(24).cast::<u16>());
                                                                            (
                                                                                l92 as u16,
                                                                                l93 as u16,
                                                                                l94 as u16,
                                                                                l95 as u16,
                                                                                l96 as u16,
                                                                                l97 as u16,
                                                                                l98 as u16,
                                                                                l99 as u16,
                                                                            )
                                                                        };
                                                                        V100::Ipv6(e100)
                                                                    }
                                                                };
                                                                v100
                                                            };
                                                            DbValue::Cidr(e265)
                                                        }
                                                        25 => {
                                                            let e265 = {
                                                                let l101 = i32::from(*base.add(8).cast::<u8>());
                                                                let l102 = i32::from(*base.add(9).cast::<u8>());
                                                                let l103 = i32::from(*base.add(10).cast::<u8>());
                                                                let l104 = i32::from(*base.add(11).cast::<u8>());
                                                                let l105 = i32::from(*base.add(12).cast::<u8>());
                                                                let l106 = i32::from(*base.add(13).cast::<u8>());
                                                                super::super::super::golem::rdbms::types::MacAddress {
                                                                    octets: (
                                                                        l101 as u8,
                                                                        l102 as u8,
                                                                        l103 as u8,
                                                                        l104 as u8,
                                                                        l105 as u8,
                                                                        l106 as u8,
                                                                    ),
                                                                }
                                                            };
                                                            DbValue::Macaddr(e265)
                                                        }
                                                        26 => {
                                                            let e265 = {
                                                                let l107 = *base.add(8).cast::<*mut u8>();
                                                                let l108 = *base.add(12).cast::<usize>();
                                                                let base110 = l107;
                                                                let len110 = l108;
                                                                let mut result110 = _rt::Vec::with_capacity(len110);
                                                                for i in 0..len110 {
                                                                    let base = base110.add(i * 1);
                                                                    let e110 = {
                                                                        let l109 = i32::from(*base.add(0).cast::<u8>());
                                                                        _rt::bool_lift(l109 as u8)
                                                                    };
                                                                    result110.push(e110);
                                                                }
                                                                _rt::cabi_dealloc(base110, len110 * 1, 1);
                                                                result110
                                                            };
                                                            DbValue::Bit(e265)
                                                        }
                                                        27 => {
                                                            let e265 = {
                                                                let l111 = *base.add(8).cast::<*mut u8>();
                                                                let l112 = *base.add(12).cast::<usize>();
                                                                let base114 = l111;
                                                                let len114 = l112;
                                                                let mut result114 = _rt::Vec::with_capacity(len114);
                                                                for i in 0..len114 {
                                                                    let base = base114.add(i * 1);
                                                                    let e114 = {
                                                                        let l113 = i32::from(*base.add(0).cast::<u8>());
                                                                        _rt::bool_lift(l113 as u8)
                                                                    };
                                                                    result114.push(e114);
                                                                }
                                                                _rt::cabi_dealloc(base114, len114 * 1, 1);
                                                                result114
                                                            };
                                                            DbValue::Varbit(e265)
                                                        }
                                                        28 => {
                                                            let e265 = {
                                                                let l115 = i32::from(*base.add(8).cast::<u8>());
                                                                let v118 = match l115 {
                                                                    0 => {
                                                                        let e118 = {
                                                                            let l116 = *base.add(12).cast::<i32>();
                                                                            l116
                                                                        };
                                                                        Int4bound::Included(e118)
                                                                    }
                                                                    1 => {
                                                                        let e118 = {
                                                                            let l117 = *base.add(12).cast::<i32>();
                                                                            l117
                                                                        };
                                                                        Int4bound::Excluded(e118)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Int4bound::Unbounded
                                                                    }
                                                                };
                                                                let l119 = i32::from(*base.add(16).cast::<u8>());
                                                                let v122 = match l119 {
                                                                    0 => {
                                                                        let e122 = {
                                                                            let l120 = *base.add(20).cast::<i32>();
                                                                            l120
                                                                        };
                                                                        Int4bound::Included(e122)
                                                                    }
                                                                    1 => {
                                                                        let e122 = {
                                                                            let l121 = *base.add(20).cast::<i32>();
                                                                            l121
                                                                        };
                                                                        Int4bound::Excluded(e122)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Int4bound::Unbounded
                                                                    }
                                                                };
                                                                Int4range {
                                                                    start: v118,
                                                                    end: v122,
                                                                }
                                                            };
                                                            DbValue::Int4range(e265)
                                                        }
                                                        29 => {
                                                            let e265 = {
                                                                let l123 = i32::from(*base.add(8).cast::<u8>());
                                                                let v126 = match l123 {
                                                                    0 => {
                                                                        let e126 = {
                                                                            let l124 = *base.add(16).cast::<i64>();
                                                                            l124
                                                                        };
                                                                        Int8bound::Included(e126)
                                                                    }
                                                                    1 => {
                                                                        let e126 = {
                                                                            let l125 = *base.add(16).cast::<i64>();
                                                                            l125
                                                                        };
                                                                        Int8bound::Excluded(e126)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Int8bound::Unbounded
                                                                    }
                                                                };
                                                                let l127 = i32::from(*base.add(24).cast::<u8>());
                                                                let v130 = match l127 {
                                                                    0 => {
                                                                        let e130 = {
                                                                            let l128 = *base.add(32).cast::<i64>();
                                                                            l128
                                                                        };
                                                                        Int8bound::Included(e130)
                                                                    }
                                                                    1 => {
                                                                        let e130 = {
                                                                            let l129 = *base.add(32).cast::<i64>();
                                                                            l129
                                                                        };
                                                                        Int8bound::Excluded(e130)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Int8bound::Unbounded
                                                                    }
                                                                };
                                                                Int8range {
                                                                    start: v126,
                                                                    end: v130,
                                                                }
                                                            };
                                                            DbValue::Int8range(e265)
                                                        }
                                                        30 => {
                                                            let e265 = {
                                                                let l131 = i32::from(*base.add(8).cast::<u8>());
                                                                let v138 = match l131 {
                                                                    0 => {
                                                                        let e138 = {
                                                                            let l132 = *base.add(12).cast::<*mut u8>();
                                                                            let l133 = *base.add(16).cast::<usize>();
                                                                            let len134 = l133;
                                                                            let bytes134 = _rt::Vec::from_raw_parts(
                                                                                l132.cast(),
                                                                                len134,
                                                                                len134,
                                                                            );
                                                                            _rt::string_lift(bytes134)
                                                                        };
                                                                        Numbound::Included(e138)
                                                                    }
                                                                    1 => {
                                                                        let e138 = {
                                                                            let l135 = *base.add(12).cast::<*mut u8>();
                                                                            let l136 = *base.add(16).cast::<usize>();
                                                                            let len137 = l136;
                                                                            let bytes137 = _rt::Vec::from_raw_parts(
                                                                                l135.cast(),
                                                                                len137,
                                                                                len137,
                                                                            );
                                                                            _rt::string_lift(bytes137)
                                                                        };
                                                                        Numbound::Excluded(e138)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Numbound::Unbounded
                                                                    }
                                                                };
                                                                let l139 = i32::from(*base.add(20).cast::<u8>());
                                                                let v146 = match l139 {
                                                                    0 => {
                                                                        let e146 = {
                                                                            let l140 = *base.add(24).cast::<*mut u8>();
                                                                            let l141 = *base.add(28).cast::<usize>();
                                                                            let len142 = l141;
                                                                            let bytes142 = _rt::Vec::from_raw_parts(
                                                                                l140.cast(),
                                                                                len142,
                                                                                len142,
                                                                            );
                                                                            _rt::string_lift(bytes142)
                                                                        };
                                                                        Numbound::Included(e146)
                                                                    }
                                                                    1 => {
                                                                        let e146 = {
                                                                            let l143 = *base.add(24).cast::<*mut u8>();
                                                                            let l144 = *base.add(28).cast::<usize>();
                                                                            let len145 = l144;
                                                                            let bytes145 = _rt::Vec::from_raw_parts(
                                                                                l143.cast(),
                                                                                len145,
                                                                                len145,
                                                                            );
                                                                            _rt::string_lift(bytes145)
                                                                        };
                                                                        Numbound::Excluded(e146)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Numbound::Unbounded
                                                                    }
                                                                };
                                                                Numrange { start: v138, end: v146 }
                                                            };
                                                            DbValue::Numrange(e265)
                                                        }
                                                        31 => {
                                                            let e265 = {
                                                                let l147 = i32::from(*base.add(8).cast::<u8>());
                                                                let v162 = match l147 {
                                                                    0 => {
                                                                        let e162 = {
                                                                            let l148 = *base.add(12).cast::<i32>();
                                                                            let l149 = i32::from(*base.add(16).cast::<u8>());
                                                                            let l150 = i32::from(*base.add(17).cast::<u8>());
                                                                            let l151 = i32::from(*base.add(20).cast::<u8>());
                                                                            let l152 = i32::from(*base.add(21).cast::<u8>());
                                                                            let l153 = i32::from(*base.add(22).cast::<u8>());
                                                                            let l154 = *base.add(24).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamp {
                                                                                date: super::super::super::golem::rdbms::types::Date {
                                                                                    year: l148,
                                                                                    month: l149 as u8,
                                                                                    day: l150 as u8,
                                                                                },
                                                                                time: super::super::super::golem::rdbms::types::Time {
                                                                                    hour: l151 as u8,
                                                                                    minute: l152 as u8,
                                                                                    second: l153 as u8,
                                                                                    nanosecond: l154 as u32,
                                                                                },
                                                                            }
                                                                        };
                                                                        Tsbound::Included(e162)
                                                                    }
                                                                    1 => {
                                                                        let e162 = {
                                                                            let l155 = *base.add(12).cast::<i32>();
                                                                            let l156 = i32::from(*base.add(16).cast::<u8>());
                                                                            let l157 = i32::from(*base.add(17).cast::<u8>());
                                                                            let l158 = i32::from(*base.add(20).cast::<u8>());
                                                                            let l159 = i32::from(*base.add(21).cast::<u8>());
                                                                            let l160 = i32::from(*base.add(22).cast::<u8>());
                                                                            let l161 = *base.add(24).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamp {
                                                                                date: super::super::super::golem::rdbms::types::Date {
                                                                                    year: l155,
                                                                                    month: l156 as u8,
                                                                                    day: l157 as u8,
                                                                                },
                                                                                time: super::super::super::golem::rdbms::types::Time {
                                                                                    hour: l158 as u8,
                                                                                    minute: l159 as u8,
                                                                                    second: l160 as u8,
                                                                                    nanosecond: l161 as u32,
                                                                                },
                                                                            }
                                                                        };
                                                                        Tsbound::Excluded(e162)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Tsbound::Unbounded
                                                                    }
                                                                };
                                                                let l163 = i32::from(*base.add(28).cast::<u8>());
                                                                let v178 = match l163 {
                                                                    0 => {
                                                                        let e178 = {
                                                                            let l164 = *base.add(32).cast::<i32>();
                                                                            let l165 = i32::from(*base.add(36).cast::<u8>());
                                                                            let l166 = i32::from(*base.add(37).cast::<u8>());
                                                                            let l167 = i32::from(*base.add(40).cast::<u8>());
                                                                            let l168 = i32::from(*base.add(41).cast::<u8>());
                                                                            let l169 = i32::from(*base.add(42).cast::<u8>());
                                                                            let l170 = *base.add(44).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamp {
                                                                                date: super::super::super::golem::rdbms::types::Date {
                                                                                    year: l164,
                                                                                    month: l165 as u8,
                                                                                    day: l166 as u8,
                                                                                },
                                                                                time: super::super::super::golem::rdbms::types::Time {
                                                                                    hour: l167 as u8,
                                                                                    minute: l168 as u8,
                                                                                    second: l169 as u8,
                                                                                    nanosecond: l170 as u32,
                                                                                },
                                                                            }
                                                                        };
                                                                        Tsbound::Included(e178)
                                                                    }
                                                                    1 => {
                                                                        let e178 = {
                                                                            let l171 = *base.add(32).cast::<i32>();
                                                                            let l172 = i32::from(*base.add(36).cast::<u8>());
                                                                            let l173 = i32::from(*base.add(37).cast::<u8>());
                                                                            let l174 = i32::from(*base.add(40).cast::<u8>());
                                                                            let l175 = i32::from(*base.add(41).cast::<u8>());
                                                                            let l176 = i32::from(*base.add(42).cast::<u8>());
                                                                            let l177 = *base.add(44).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamp {
                                                                                date: super::super::super::golem::rdbms::types::Date {
                                                                                    year: l171,
                                                                                    month: l172 as u8,
                                                                                    day: l173 as u8,
                                                                                },
                                                                                time: super::super::super::golem::rdbms::types::Time {
                                                                                    hour: l174 as u8,
                                                                                    minute: l175 as u8,
                                                                                    second: l176 as u8,
                                                                                    nanosecond: l177 as u32,
                                                                                },
                                                                            }
                                                                        };
                                                                        Tsbound::Excluded(e178)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Tsbound::Unbounded
                                                                    }
                                                                };
                                                                Tsrange { start: v162, end: v178 }
                                                            };
                                                            DbValue::Tsrange(e265)
                                                        }
                                                        32 => {
                                                            let e265 = {
                                                                let l179 = i32::from(*base.add(8).cast::<u8>());
                                                                let v196 = match l179 {
                                                                    0 => {
                                                                        let e196 = {
                                                                            let l180 = *base.add(12).cast::<i32>();
                                                                            let l181 = i32::from(*base.add(16).cast::<u8>());
                                                                            let l182 = i32::from(*base.add(17).cast::<u8>());
                                                                            let l183 = i32::from(*base.add(20).cast::<u8>());
                                                                            let l184 = i32::from(*base.add(21).cast::<u8>());
                                                                            let l185 = i32::from(*base.add(22).cast::<u8>());
                                                                            let l186 = *base.add(24).cast::<i32>();
                                                                            let l187 = *base.add(28).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamptz {
                                                                                timestamp: super::super::super::golem::rdbms::types::Timestamp {
                                                                                    date: super::super::super::golem::rdbms::types::Date {
                                                                                        year: l180,
                                                                                        month: l181 as u8,
                                                                                        day: l182 as u8,
                                                                                    },
                                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                                        hour: l183 as u8,
                                                                                        minute: l184 as u8,
                                                                                        second: l185 as u8,
                                                                                        nanosecond: l186 as u32,
                                                                                    },
                                                                                },
                                                                                offset: l187,
                                                                            }
                                                                        };
                                                                        Tstzbound::Included(e196)
                                                                    }
                                                                    1 => {
                                                                        let e196 = {
                                                                            let l188 = *base.add(12).cast::<i32>();
                                                                            let l189 = i32::from(*base.add(16).cast::<u8>());
                                                                            let l190 = i32::from(*base.add(17).cast::<u8>());
                                                                            let l191 = i32::from(*base.add(20).cast::<u8>());
                                                                            let l192 = i32::from(*base.add(21).cast::<u8>());
                                                                            let l193 = i32::from(*base.add(22).cast::<u8>());
                                                                            let l194 = *base.add(24).cast::<i32>();
                                                                            let l195 = *base.add(28).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamptz {
                                                                                timestamp: super::super::super::golem::rdbms::types::Timestamp {
                                                                                    date: super::super::super::golem::rdbms::types::Date {
                                                                                        year: l188,
                                                                                        month: l189 as u8,
                                                                                        day: l190 as u8,
                                                                                    },
                                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                                        hour: l191 as u8,
                                                                                        minute: l192 as u8,
                                                                                        second: l193 as u8,
                                                                                        nanosecond: l194 as u32,
                                                                                    },
                                                                                },
                                                                                offset: l195,
                                                                            }
                                                                        };
                                                                        Tstzbound::Excluded(e196)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Tstzbound::Unbounded
                                                                    }
                                                                };
                                                                let l197 = i32::from(*base.add(32).cast::<u8>());
                                                                let v214 = match l197 {
                                                                    0 => {
                                                                        let e214 = {
                                                                            let l198 = *base.add(36).cast::<i32>();
                                                                            let l199 = i32::from(*base.add(40).cast::<u8>());
                                                                            let l200 = i32::from(*base.add(41).cast::<u8>());
                                                                            let l201 = i32::from(*base.add(44).cast::<u8>());
                                                                            let l202 = i32::from(*base.add(45).cast::<u8>());
                                                                            let l203 = i32::from(*base.add(46).cast::<u8>());
                                                                            let l204 = *base.add(48).cast::<i32>();
                                                                            let l205 = *base.add(52).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamptz {
                                                                                timestamp: super::super::super::golem::rdbms::types::Timestamp {
                                                                                    date: super::super::super::golem::rdbms::types::Date {
                                                                                        year: l198,
                                                                                        month: l199 as u8,
                                                                                        day: l200 as u8,
                                                                                    },
                                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                                        hour: l201 as u8,
                                                                                        minute: l202 as u8,
                                                                                        second: l203 as u8,
                                                                                        nanosecond: l204 as u32,
                                                                                    },
                                                                                },
                                                                                offset: l205,
                                                                            }
                                                                        };
                                                                        Tstzbound::Included(e214)
                                                                    }
                                                                    1 => {
                                                                        let e214 = {
                                                                            let l206 = *base.add(36).cast::<i32>();
                                                                            let l207 = i32::from(*base.add(40).cast::<u8>());
                                                                            let l208 = i32::from(*base.add(41).cast::<u8>());
                                                                            let l209 = i32::from(*base.add(44).cast::<u8>());
                                                                            let l210 = i32::from(*base.add(45).cast::<u8>());
                                                                            let l211 = i32::from(*base.add(46).cast::<u8>());
                                                                            let l212 = *base.add(48).cast::<i32>();
                                                                            let l213 = *base.add(52).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamptz {
                                                                                timestamp: super::super::super::golem::rdbms::types::Timestamp {
                                                                                    date: super::super::super::golem::rdbms::types::Date {
                                                                                        year: l206,
                                                                                        month: l207 as u8,
                                                                                        day: l208 as u8,
                                                                                    },
                                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                                        hour: l209 as u8,
                                                                                        minute: l210 as u8,
                                                                                        second: l211 as u8,
                                                                                        nanosecond: l212 as u32,
                                                                                    },
                                                                                },
                                                                                offset: l213,
                                                                            }
                                                                        };
                                                                        Tstzbound::Excluded(e214)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Tstzbound::Unbounded
                                                                    }
                                                                };
                                                                Tstzrange {
                                                                    start: v196,
                                                                    end: v214,
                                                                }
                                                            };
                                                            DbValue::Tstzrange(e265)
                                                        }
                                                        33 => {
                                                            let e265 = {
                                                                let l215 = i32::from(*base.add(8).cast::<u8>());
                                                                let v222 = match l215 {
                                                                    0 => {
                                                                        let e222 = {
                                                                            let l216 = *base.add(12).cast::<i32>();
                                                                            let l217 = i32::from(*base.add(16).cast::<u8>());
                                                                            let l218 = i32::from(*base.add(17).cast::<u8>());
                                                                            super::super::super::golem::rdbms::types::Date {
                                                                                year: l216,
                                                                                month: l217 as u8,
                                                                                day: l218 as u8,
                                                                            }
                                                                        };
                                                                        Datebound::Included(e222)
                                                                    }
                                                                    1 => {
                                                                        let e222 = {
                                                                            let l219 = *base.add(12).cast::<i32>();
                                                                            let l220 = i32::from(*base.add(16).cast::<u8>());
                                                                            let l221 = i32::from(*base.add(17).cast::<u8>());
                                                                            super::super::super::golem::rdbms::types::Date {
                                                                                year: l219,
                                                                                month: l220 as u8,
                                                                                day: l221 as u8,
                                                                            }
                                                                        };
                                                                        Datebound::Excluded(e222)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Datebound::Unbounded
                                                                    }
                                                                };
                                                                let l223 = i32::from(*base.add(20).cast::<u8>());
                                                                let v230 = match l223 {
                                                                    0 => {
                                                                        let e230 = {
                                                                            let l224 = *base.add(24).cast::<i32>();
                                                                            let l225 = i32::from(*base.add(28).cast::<u8>());
                                                                            let l226 = i32::from(*base.add(29).cast::<u8>());
                                                                            super::super::super::golem::rdbms::types::Date {
                                                                                year: l224,
                                                                                month: l225 as u8,
                                                                                day: l226 as u8,
                                                                            }
                                                                        };
                                                                        Datebound::Included(e230)
                                                                    }
                                                                    1 => {
                                                                        let e230 = {
                                                                            let l227 = *base.add(24).cast::<i32>();
                                                                            let l228 = i32::from(*base.add(28).cast::<u8>());
                                                                            let l229 = i32::from(*base.add(29).cast::<u8>());
                                                                            super::super::super::golem::rdbms::types::Date {
                                                                                year: l227,
                                                                                month: l228 as u8,
                                                                                day: l229 as u8,
                                                                            }
                                                                        };
                                                                        Datebound::Excluded(e230)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Datebound::Unbounded
                                                                    }
                                                                };
                                                                Daterange {
                                                                    start: v222,
                                                                    end: v230,
                                                                }
                                                            };
                                                            DbValue::Daterange(e265)
                                                        }
                                                        34 => {
                                                            let e265 = {
                                                                let l231 = *base.add(8).cast::<i64>();
                                                                l231
                                                            };
                                                            DbValue::Money(e265)
                                                        }
                                                        35 => {
                                                            let e265 = {
                                                                let l232 = *base.add(8).cast::<i32>();
                                                                l232 as u32
                                                            };
                                                            DbValue::Oid(e265)
                                                        }
                                                        36 => {
                                                            let e265 = {
                                                                let l233 = *base.add(8).cast::<*mut u8>();
                                                                let l234 = *base.add(12).cast::<usize>();
                                                                let len235 = l234;
                                                                let bytes235 = _rt::Vec::from_raw_parts(
                                                                    l233.cast(),
                                                                    len235,
                                                                    len235,
                                                                );
                                                                let l236 = *base.add(16).cast::<*mut u8>();
                                                                let l237 = *base.add(20).cast::<usize>();
                                                                let len238 = l237;
                                                                let bytes238 = _rt::Vec::from_raw_parts(
                                                                    l236.cast(),
                                                                    len238,
                                                                    len238,
                                                                );
                                                                Enumeration {
                                                                    name: _rt::string_lift(bytes235),
                                                                    value: _rt::string_lift(bytes238),
                                                                }
                                                            };
                                                            DbValue::Enumeration(e265)
                                                        }
                                                        37 => {
                                                            let e265 = {
                                                                let l239 = *base.add(8).cast::<*mut u8>();
                                                                let l240 = *base.add(12).cast::<usize>();
                                                                let len241 = l240;
                                                                let bytes241 = _rt::Vec::from_raw_parts(
                                                                    l239.cast(),
                                                                    len241,
                                                                    len241,
                                                                );
                                                                let l242 = *base.add(16).cast::<*mut u8>();
                                                                let l243 = *base.add(20).cast::<usize>();
                                                                let base245 = l242;
                                                                let len245 = l243;
                                                                let mut result245 = _rt::Vec::with_capacity(len245);
                                                                for i in 0..len245 {
                                                                    let base = base245.add(i * 4);
                                                                    let e245 = {
                                                                        let l244 = *base.add(0).cast::<i32>();
                                                                        LazyDbValue::from_handle(l244 as u32)
                                                                    };
                                                                    result245.push(e245);
                                                                }
                                                                _rt::cabi_dealloc(base245, len245 * 4, 4);
                                                                Composite {
                                                                    name: _rt::string_lift(bytes241),
                                                                    values: result245,
                                                                }
                                                            };
                                                            DbValue::Composite(e265)
                                                        }
                                                        38 => {
                                                            let e265 = {
                                                                let l246 = *base.add(8).cast::<*mut u8>();
                                                                let l247 = *base.add(12).cast::<usize>();
                                                                let len248 = l247;
                                                                let bytes248 = _rt::Vec::from_raw_parts(
                                                                    l246.cast(),
                                                                    len248,
                                                                    len248,
                                                                );
                                                                let l249 = *base.add(16).cast::<i32>();
                                                                Domain {
                                                                    name: _rt::string_lift(bytes248),
                                                                    value: LazyDbValue::from_handle(l249 as u32),
                                                                }
                                                            };
                                                            DbValue::Domain(e265)
                                                        }
                                                        39 => {
                                                            let e265 = {
                                                                let l250 = *base.add(8).cast::<*mut u8>();
                                                                let l251 = *base.add(12).cast::<usize>();
                                                                let base253 = l250;
                                                                let len253 = l251;
                                                                let mut result253 = _rt::Vec::with_capacity(len253);
                                                                for i in 0..len253 {
                                                                    let base = base253.add(i * 4);
                                                                    let e253 = {
                                                                        let l252 = *base.add(0).cast::<i32>();
                                                                        LazyDbValue::from_handle(l252 as u32)
                                                                    };
                                                                    result253.push(e253);
                                                                }
                                                                _rt::cabi_dealloc(base253, len253 * 4, 4);
                                                                result253
                                                            };
                                                            DbValue::Array(e265)
                                                        }
                                                        40 => {
                                                            let e265 = {
                                                                let l254 = *base.add(8).cast::<*mut u8>();
                                                                let l255 = *base.add(12).cast::<usize>();
                                                                let len256 = l255;
                                                                let bytes256 = _rt::Vec::from_raw_parts(
                                                                    l254.cast(),
                                                                    len256,
                                                                    len256,
                                                                );
                                                                let l257 = i32::from(*base.add(16).cast::<u8>());
                                                                let v260 = match l257 {
                                                                    0 => {
                                                                        let e260 = {
                                                                            let l258 = *base.add(20).cast::<i32>();
                                                                            LazyDbValue::from_handle(l258 as u32)
                                                                        };
                                                                        ValueBound::Included(e260)
                                                                    }
                                                                    1 => {
                                                                        let e260 = {
                                                                            let l259 = *base.add(20).cast::<i32>();
                                                                            LazyDbValue::from_handle(l259 as u32)
                                                                        };
                                                                        ValueBound::Excluded(e260)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        ValueBound::Unbounded
                                                                    }
                                                                };
                                                                let l261 = i32::from(*base.add(24).cast::<u8>());
                                                                let v264 = match l261 {
                                                                    0 => {
                                                                        let e264 = {
                                                                            let l262 = *base.add(28).cast::<i32>();
                                                                            LazyDbValue::from_handle(l262 as u32)
                                                                        };
                                                                        ValueBound::Included(e264)
                                                                    }
                                                                    1 => {
                                                                        let e264 = {
                                                                            let l263 = *base.add(28).cast::<i32>();
                                                                            LazyDbValue::from_handle(l263 as u32)
                                                                        };
                                                                        ValueBound::Excluded(e264)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        ValueBound::Unbounded
                                                                    }
                                                                };
                                                                Range {
                                                                    name: _rt::string_lift(bytes256),
                                                                    value: ValuesRange {
                                                                        start: v260,
                                                                        end: v264,
                                                                    },
                                                                }
                                                            };
                                                            DbValue::Range(e265)
                                                        }
                                                        n => {
                                                            debug_assert_eq!(n, 41, "invalid enum discriminant");
                                                            DbValue::Null
                                                        }
                                                    };
                                                    v265
                                                };
                                                result266.push(e266);
                                            }
                                            _rt::cabi_dealloc(base266, len266 * 56, 8);
                                            DbRow { values: result266 }
                                        };
                                        result267.push(e267);
                                    }
                                    _rt::cabi_dealloc(base267, len267 * 8, 4);
                                    result267
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl DbConnection {
                #[allow(unused_unsafe, clippy::all)]
                pub fn open(address: &str) -> Result<DbConnection, Error> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 16]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 16],
                        );
                        let vec0 = address;
                        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 = "golem:rdbms/postgres@0.0.1")]
                        extern "C" {
                            #[link_name = "[static]db-connection.open"]
                            fn wit_import(_: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: *mut u8, _: usize, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import(ptr0.cast_mut(), len0, ptr1);
                        let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                        match l2 {
                            0 => {
                                let e = {
                                    let l3 = *ptr1.add(4).cast::<i32>();
                                    DbConnection::from_handle(l3 as u32)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l4 = i32::from(*ptr1.add(4).cast::<u8>());
                                    let v20 = match l4 {
                                        0 => {
                                            let e20 = {
                                                let l5 = *ptr1.add(8).cast::<*mut u8>();
                                                let l6 = *ptr1.add(12).cast::<usize>();
                                                let len7 = l6;
                                                let bytes7 = _rt::Vec::from_raw_parts(
                                                    l5.cast(),
                                                    len7,
                                                    len7,
                                                );
                                                _rt::string_lift(bytes7)
                                            };
                                            Error::ConnectionFailure(e20)
                                        }
                                        1 => {
                                            let e20 = {
                                                let l8 = *ptr1.add(8).cast::<*mut u8>();
                                                let l9 = *ptr1.add(12).cast::<usize>();
                                                let len10 = l9;
                                                let bytes10 = _rt::Vec::from_raw_parts(
                                                    l8.cast(),
                                                    len10,
                                                    len10,
                                                );
                                                _rt::string_lift(bytes10)
                                            };
                                            Error::QueryParameterFailure(e20)
                                        }
                                        2 => {
                                            let e20 = {
                                                let l11 = *ptr1.add(8).cast::<*mut u8>();
                                                let l12 = *ptr1.add(12).cast::<usize>();
                                                let len13 = l12;
                                                let bytes13 = _rt::Vec::from_raw_parts(
                                                    l11.cast(),
                                                    len13,
                                                    len13,
                                                );
                                                _rt::string_lift(bytes13)
                                            };
                                            Error::QueryExecutionFailure(e20)
                                        }
                                        3 => {
                                            let e20 = {
                                                let l14 = *ptr1.add(8).cast::<*mut u8>();
                                                let l15 = *ptr1.add(12).cast::<usize>();
                                                let len16 = l15;
                                                let bytes16 = _rt::Vec::from_raw_parts(
                                                    l14.cast(),
                                                    len16,
                                                    len16,
                                                );
                                                _rt::string_lift(bytes16)
                                            };
                                            Error::QueryResponseFailure(e20)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 4, "invalid enum discriminant");
                                            let e20 = {
                                                let l17 = *ptr1.add(8).cast::<*mut u8>();
                                                let l18 = *ptr1.add(12).cast::<usize>();
                                                let len19 = l18;
                                                let bytes19 = _rt::Vec::from_raw_parts(
                                                    l17.cast(),
                                                    len19,
                                                    len19,
                                                );
                                                _rt::string_lift(bytes19)
                                            };
                                            Error::Other(e20)
                                        }
                                    };
                                    v20
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl DbConnection {
                #[allow(unused_unsafe, clippy::all)]
                pub fn query(
                    &self,
                    statement: &str,
                    params: _rt::Vec<DbValue>,
                ) -> Result<DbResult, Error> {
                    unsafe {
                        let mut cleanup_list = _rt::Vec::new();
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 20]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 20],
                        );
                        let vec0 = statement;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let vec87 = &params;
                        let len87 = vec87.len();
                        let layout87 = _rt::alloc::Layout::from_size_align_unchecked(
                            vec87.len() * 56,
                            8,
                        );
                        let result87 = if layout87.size() != 0 {
                            let ptr = _rt::alloc::alloc(layout87).cast::<u8>();
                            if ptr.is_null() {
                                _rt::alloc::handle_alloc_error(layout87);
                            }
                            ptr
                        } else {
                            ::core::ptr::null_mut()
                        };
                        for (i, e) in vec87.into_iter().enumerate() {
                            let base = result87.add(i * 56);
                            {
                                match e {
                                    DbValue::Character(e) => {
                                        *base.add(0).cast::<u8>() = (0i32) as u8;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                    }
                                    DbValue::Int2(e) => {
                                        *base.add(0).cast::<u8>() = (1i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::Int4(e) => {
                                        *base.add(0).cast::<u8>() = (2i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Int8(e) => {
                                        *base.add(0).cast::<u8>() = (3i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::Float4(e) => {
                                        *base.add(0).cast::<u8>() = (4i32) as u8;
                                        *base.add(8).cast::<f32>() = _rt::as_f32(e);
                                    }
                                    DbValue::Float8(e) => {
                                        *base.add(0).cast::<u8>() = (5i32) as u8;
                                        *base.add(8).cast::<f64>() = _rt::as_f64(e);
                                    }
                                    DbValue::Numeric(e) => {
                                        *base.add(0).cast::<u8>() = (6i32) as u8;
                                        let vec1 = e;
                                        let ptr1 = vec1.as_ptr().cast::<u8>();
                                        let len1 = vec1.len();
                                        *base.add(12).cast::<usize>() = len1;
                                        *base.add(8).cast::<*mut u8>() = ptr1.cast_mut();
                                    }
                                    DbValue::Boolean(e) => {
                                        *base.add(0).cast::<u8>() = (7i32) as u8;
                                        *base.add(8).cast::<u8>() = (match e {
                                            true => 1,
                                            false => 0,
                                        }) as u8;
                                    }
                                    DbValue::Text(e) => {
                                        *base.add(0).cast::<u8>() = (8i32) as u8;
                                        let vec2 = e;
                                        let ptr2 = vec2.as_ptr().cast::<u8>();
                                        let len2 = vec2.len();
                                        *base.add(12).cast::<usize>() = len2;
                                        *base.add(8).cast::<*mut u8>() = ptr2.cast_mut();
                                    }
                                    DbValue::Varchar(e) => {
                                        *base.add(0).cast::<u8>() = (9i32) as u8;
                                        let vec3 = e;
                                        let ptr3 = vec3.as_ptr().cast::<u8>();
                                        let len3 = vec3.len();
                                        *base.add(12).cast::<usize>() = len3;
                                        *base.add(8).cast::<*mut u8>() = ptr3.cast_mut();
                                    }
                                    DbValue::Bpchar(e) => {
                                        *base.add(0).cast::<u8>() = (10i32) as u8;
                                        let vec4 = e;
                                        let ptr4 = vec4.as_ptr().cast::<u8>();
                                        let len4 = vec4.len();
                                        *base.add(12).cast::<usize>() = len4;
                                        *base.add(8).cast::<*mut u8>() = ptr4.cast_mut();
                                    }
                                    DbValue::Timestamp(e) => {
                                        *base.add(0).cast::<u8>() = (11i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date5,
                                            time: time5,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year6,
                                            month: month6,
                                            day: day6,
                                        } = date5;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year6);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month6)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day6)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour7,
                                            minute: minute7,
                                            second: second7,
                                            nanosecond: nanosecond7,
                                        } = time5;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour7)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute7)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second7)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond7);
                                    }
                                    DbValue::Timestamptz(e) => {
                                        *base.add(0).cast::<u8>() = (12i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamptz {
                                            timestamp: timestamp8,
                                            offset: offset8,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date9,
                                            time: time9,
                                        } = timestamp8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year10,
                                            month: month10,
                                            day: day10,
                                        } = date9;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year10);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month10)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day10)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour11,
                                            minute: minute11,
                                            second: second11,
                                            nanosecond: nanosecond11,
                                        } = time9;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour11)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute11)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second11)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond11);
                                        *base.add(24).cast::<i32>() = _rt::as_i32(offset8);
                                    }
                                    DbValue::Date(e) => {
                                        *base.add(0).cast::<u8>() = (13i32) as u8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year12,
                                            month: month12,
                                            day: day12,
                                        } = e;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year12);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month12)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day12)) as u8;
                                    }
                                    DbValue::Time(e) => {
                                        *base.add(0).cast::<u8>() = (14i32) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour13,
                                            minute: minute13,
                                            second: second13,
                                            nanosecond: nanosecond13,
                                        } = e;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(hour13)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(minute13)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(second13)) as u8;
                                        *base.add(12).cast::<i32>() = _rt::as_i32(nanosecond13);
                                    }
                                    DbValue::Timetz(e) => {
                                        *base.add(0).cast::<u8>() = (15i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timetz {
                                            time: time14,
                                            offset: offset14,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour15,
                                            minute: minute15,
                                            second: second15,
                                            nanosecond: nanosecond15,
                                        } = time14;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(hour15)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(minute15)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(second15)) as u8;
                                        *base.add(12).cast::<i32>() = _rt::as_i32(nanosecond15);
                                        *base.add(16).cast::<i32>() = _rt::as_i32(offset14);
                                    }
                                    DbValue::Interval(e) => {
                                        *base.add(0).cast::<u8>() = (16i32) as u8;
                                        let Interval {
                                            months: months16,
                                            days: days16,
                                            microseconds: microseconds16,
                                        } = e;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(months16);
                                        *base.add(12).cast::<i32>() = _rt::as_i32(days16);
                                        *base.add(16).cast::<i64>() = _rt::as_i64(microseconds16);
                                    }
                                    DbValue::Bytea(e) => {
                                        *base.add(0).cast::<u8>() = (17i32) as u8;
                                        let vec17 = e;
                                        let ptr17 = vec17.as_ptr().cast::<u8>();
                                        let len17 = vec17.len();
                                        *base.add(12).cast::<usize>() = len17;
                                        *base.add(8).cast::<*mut u8>() = ptr17.cast_mut();
                                    }
                                    DbValue::Json(e) => {
                                        *base.add(0).cast::<u8>() = (18i32) as u8;
                                        let vec18 = e;
                                        let ptr18 = vec18.as_ptr().cast::<u8>();
                                        let len18 = vec18.len();
                                        *base.add(12).cast::<usize>() = len18;
                                        *base.add(8).cast::<*mut u8>() = ptr18.cast_mut();
                                    }
                                    DbValue::Jsonb(e) => {
                                        *base.add(0).cast::<u8>() = (19i32) as u8;
                                        let vec19 = e;
                                        let ptr19 = vec19.as_ptr().cast::<u8>();
                                        let len19 = vec19.len();
                                        *base.add(12).cast::<usize>() = len19;
                                        *base.add(8).cast::<*mut u8>() = ptr19.cast_mut();
                                    }
                                    DbValue::Jsonpath(e) => {
                                        *base.add(0).cast::<u8>() = (20i32) as u8;
                                        let vec20 = e;
                                        let ptr20 = vec20.as_ptr().cast::<u8>();
                                        let len20 = vec20.len();
                                        *base.add(12).cast::<usize>() = len20;
                                        *base.add(8).cast::<*mut u8>() = ptr20.cast_mut();
                                    }
                                    DbValue::Xml(e) => {
                                        *base.add(0).cast::<u8>() = (21i32) as u8;
                                        let vec21 = e;
                                        let ptr21 = vec21.as_ptr().cast::<u8>();
                                        let len21 = vec21.len();
                                        *base.add(12).cast::<usize>() = len21;
                                        *base.add(8).cast::<*mut u8>() = ptr21.cast_mut();
                                    }
                                    DbValue::Uuid(e) => {
                                        *base.add(0).cast::<u8>() = (22i32) as u8;
                                        let super::super::super::golem::rdbms::types::Uuid {
                                            high_bits: high_bits22,
                                            low_bits: low_bits22,
                                        } = e;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(high_bits22);
                                        *base.add(16).cast::<i64>() = _rt::as_i64(low_bits22);
                                    }
                                    DbValue::Inet(e) => {
                                        *base.add(0).cast::<u8>() = (23i32) as u8;
                                        use super::super::super::golem::rdbms::types::IpAddress as V25;
                                        match e {
                                            V25::Ipv4(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let (t23_0, t23_1, t23_2, t23_3) = e;
                                                *base.add(10).cast::<u8>() = (_rt::as_i32(t23_0)) as u8;
                                                *base.add(11).cast::<u8>() = (_rt::as_i32(t23_1)) as u8;
                                                *base.add(12).cast::<u8>() = (_rt::as_i32(t23_2)) as u8;
                                                *base.add(13).cast::<u8>() = (_rt::as_i32(t23_3)) as u8;
                                            }
                                            V25::Ipv6(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let (
                                                    t24_0,
                                                    t24_1,
                                                    t24_2,
                                                    t24_3,
                                                    t24_4,
                                                    t24_5,
                                                    t24_6,
                                                    t24_7,
                                                ) = e;
                                                *base.add(10).cast::<u16>() = (_rt::as_i32(t24_0)) as u16;
                                                *base.add(12).cast::<u16>() = (_rt::as_i32(t24_1)) as u16;
                                                *base.add(14).cast::<u16>() = (_rt::as_i32(t24_2)) as u16;
                                                *base.add(16).cast::<u16>() = (_rt::as_i32(t24_3)) as u16;
                                                *base.add(18).cast::<u16>() = (_rt::as_i32(t24_4)) as u16;
                                                *base.add(20).cast::<u16>() = (_rt::as_i32(t24_5)) as u16;
                                                *base.add(22).cast::<u16>() = (_rt::as_i32(t24_6)) as u16;
                                                *base.add(24).cast::<u16>() = (_rt::as_i32(t24_7)) as u16;
                                            }
                                        }
                                    }
                                    DbValue::Cidr(e) => {
                                        *base.add(0).cast::<u8>() = (24i32) as u8;
                                        use super::super::super::golem::rdbms::types::IpAddress as V28;
                                        match e {
                                            V28::Ipv4(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let (t26_0, t26_1, t26_2, t26_3) = e;
                                                *base.add(10).cast::<u8>() = (_rt::as_i32(t26_0)) as u8;
                                                *base.add(11).cast::<u8>() = (_rt::as_i32(t26_1)) as u8;
                                                *base.add(12).cast::<u8>() = (_rt::as_i32(t26_2)) as u8;
                                                *base.add(13).cast::<u8>() = (_rt::as_i32(t26_3)) as u8;
                                            }
                                            V28::Ipv6(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let (
                                                    t27_0,
                                                    t27_1,
                                                    t27_2,
                                                    t27_3,
                                                    t27_4,
                                                    t27_5,
                                                    t27_6,
                                                    t27_7,
                                                ) = e;
                                                *base.add(10).cast::<u16>() = (_rt::as_i32(t27_0)) as u16;
                                                *base.add(12).cast::<u16>() = (_rt::as_i32(t27_1)) as u16;
                                                *base.add(14).cast::<u16>() = (_rt::as_i32(t27_2)) as u16;
                                                *base.add(16).cast::<u16>() = (_rt::as_i32(t27_3)) as u16;
                                                *base.add(18).cast::<u16>() = (_rt::as_i32(t27_4)) as u16;
                                                *base.add(20).cast::<u16>() = (_rt::as_i32(t27_5)) as u16;
                                                *base.add(22).cast::<u16>() = (_rt::as_i32(t27_6)) as u16;
                                                *base.add(24).cast::<u16>() = (_rt::as_i32(t27_7)) as u16;
                                            }
                                        }
                                    }
                                    DbValue::Macaddr(e) => {
                                        *base.add(0).cast::<u8>() = (25i32) as u8;
                                        let super::super::super::golem::rdbms::types::MacAddress {
                                            octets: octets29,
                                        } = e;
                                        let (t30_0, t30_1, t30_2, t30_3, t30_4, t30_5) = octets29;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(t30_0)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(t30_1)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(t30_2)) as u8;
                                        *base.add(11).cast::<u8>() = (_rt::as_i32(t30_3)) as u8;
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(t30_4)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(t30_5)) as u8;
                                    }
                                    DbValue::Bit(e) => {
                                        *base.add(0).cast::<u8>() = (26i32) as u8;
                                        let vec31 = e;
                                        let len31 = vec31.len();
                                        let layout31 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec31.len() * 1,
                                            1,
                                        );
                                        let result31 = if layout31.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout31).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout31);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec31.into_iter().enumerate() {
                                            let base = result31.add(i * 1);
                                            {
                                                *base.add(0).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len31;
                                        *base.add(8).cast::<*mut u8>() = result31;
                                        cleanup_list.extend_from_slice(&[(result31, layout31)]);
                                    }
                                    DbValue::Varbit(e) => {
                                        *base.add(0).cast::<u8>() = (27i32) as u8;
                                        let vec32 = e;
                                        let len32 = vec32.len();
                                        let layout32 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec32.len() * 1,
                                            1,
                                        );
                                        let result32 = if layout32.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout32).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout32);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec32.into_iter().enumerate() {
                                            let base = result32.add(i * 1);
                                            {
                                                *base.add(0).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len32;
                                        *base.add(8).cast::<*mut u8>() = result32;
                                        cleanup_list.extend_from_slice(&[(result32, layout32)]);
                                    }
                                    DbValue::Int4range(e) => {
                                        *base.add(0).cast::<u8>() = (28i32) as u8;
                                        let Int4range { start: start33, end: end33 } = e;
                                        match start33 {
                                            Int4bound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end33 {
                                            Int4bound::Included(e) => {
                                                *base.add(16).cast::<u8>() = (0i32) as u8;
                                                *base.add(20).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Excluded(e) => {
                                                *base.add(16).cast::<u8>() = (1i32) as u8;
                                                *base.add(20).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Unbounded => {
                                                *base.add(16).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Int8range(e) => {
                                        *base.add(0).cast::<u8>() = (29i32) as u8;
                                        let Int8range { start: start34, end: end34 } = e;
                                        match start34 {
                                            Int8bound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                *base.add(16).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                *base.add(16).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end34 {
                                            Int8bound::Included(e) => {
                                                *base.add(24).cast::<u8>() = (0i32) as u8;
                                                *base.add(32).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Excluded(e) => {
                                                *base.add(24).cast::<u8>() = (1i32) as u8;
                                                *base.add(32).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Unbounded => {
                                                *base.add(24).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Numrange(e) => {
                                        *base.add(0).cast::<u8>() = (30i32) as u8;
                                        let Numrange { start: start35, end: end35 } = e;
                                        match start35 {
                                            Numbound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let vec36 = e;
                                                let ptr36 = vec36.as_ptr().cast::<u8>();
                                                let len36 = vec36.len();
                                                *base.add(16).cast::<usize>() = len36;
                                                *base.add(12).cast::<*mut u8>() = ptr36.cast_mut();
                                            }
                                            Numbound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let vec37 = e;
                                                let ptr37 = vec37.as_ptr().cast::<u8>();
                                                let len37 = vec37.len();
                                                *base.add(16).cast::<usize>() = len37;
                                                *base.add(12).cast::<*mut u8>() = ptr37.cast_mut();
                                            }
                                            Numbound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end35 {
                                            Numbound::Included(e) => {
                                                *base.add(20).cast::<u8>() = (0i32) as u8;
                                                let vec38 = e;
                                                let ptr38 = vec38.as_ptr().cast::<u8>();
                                                let len38 = vec38.len();
                                                *base.add(28).cast::<usize>() = len38;
                                                *base.add(24).cast::<*mut u8>() = ptr38.cast_mut();
                                            }
                                            Numbound::Excluded(e) => {
                                                *base.add(20).cast::<u8>() = (1i32) as u8;
                                                let vec39 = e;
                                                let ptr39 = vec39.as_ptr().cast::<u8>();
                                                let len39 = vec39.len();
                                                *base.add(28).cast::<usize>() = len39;
                                                *base.add(24).cast::<*mut u8>() = ptr39.cast_mut();
                                            }
                                            Numbound::Unbounded => {
                                                *base.add(20).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Tsrange(e) => {
                                        *base.add(0).cast::<u8>() = (31i32) as u8;
                                        let Tsrange { start: start40, end: end40 } = e;
                                        match start40 {
                                            Tsbound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date41,
                                                    time: time41,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year42,
                                                    month: month42,
                                                    day: day42,
                                                } = date41;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year42);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month42)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day42)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour43,
                                                    minute: minute43,
                                                    second: second43,
                                                    nanosecond: nanosecond43,
                                                } = time41;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour43)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute43)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second43)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond43);
                                            }
                                            Tsbound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date44,
                                                    time: time44,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year45,
                                                    month: month45,
                                                    day: day45,
                                                } = date44;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year45);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month45)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day45)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour46,
                                                    minute: minute46,
                                                    second: second46,
                                                    nanosecond: nanosecond46,
                                                } = time44;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour46)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute46)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second46)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond46);
                                            }
                                            Tsbound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end40 {
                                            Tsbound::Included(e) => {
                                                *base.add(28).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date47,
                                                    time: time47,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year48,
                                                    month: month48,
                                                    day: day48,
                                                } = date47;
                                                *base.add(32).cast::<i32>() = _rt::as_i32(year48);
                                                *base.add(36).cast::<u8>() = (_rt::as_i32(month48)) as u8;
                                                *base.add(37).cast::<u8>() = (_rt::as_i32(day48)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour49,
                                                    minute: minute49,
                                                    second: second49,
                                                    nanosecond: nanosecond49,
                                                } = time47;
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(hour49)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(minute49)) as u8;
                                                *base.add(42).cast::<u8>() = (_rt::as_i32(second49)) as u8;
                                                *base.add(44).cast::<i32>() = _rt::as_i32(nanosecond49);
                                            }
                                            Tsbound::Excluded(e) => {
                                                *base.add(28).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date50,
                                                    time: time50,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year51,
                                                    month: month51,
                                                    day: day51,
                                                } = date50;
                                                *base.add(32).cast::<i32>() = _rt::as_i32(year51);
                                                *base.add(36).cast::<u8>() = (_rt::as_i32(month51)) as u8;
                                                *base.add(37).cast::<u8>() = (_rt::as_i32(day51)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour52,
                                                    minute: minute52,
                                                    second: second52,
                                                    nanosecond: nanosecond52,
                                                } = time50;
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(hour52)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(minute52)) as u8;
                                                *base.add(42).cast::<u8>() = (_rt::as_i32(second52)) as u8;
                                                *base.add(44).cast::<i32>() = _rt::as_i32(nanosecond52);
                                            }
                                            Tsbound::Unbounded => {
                                                *base.add(28).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Tstzrange(e) => {
                                        *base.add(0).cast::<u8>() = (32i32) as u8;
                                        let Tstzrange { start: start53, end: end53 } = e;
                                        match start53 {
                                            Tstzbound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp54,
                                                    offset: offset54,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date55,
                                                    time: time55,
                                                } = timestamp54;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year56,
                                                    month: month56,
                                                    day: day56,
                                                } = date55;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year56);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month56)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day56)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour57,
                                                    minute: minute57,
                                                    second: second57,
                                                    nanosecond: nanosecond57,
                                                } = time55;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour57)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute57)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second57)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond57);
                                                *base.add(28).cast::<i32>() = _rt::as_i32(offset54);
                                            }
                                            Tstzbound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp58,
                                                    offset: offset58,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date59,
                                                    time: time59,
                                                } = timestamp58;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year60,
                                                    month: month60,
                                                    day: day60,
                                                } = date59;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year60);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month60)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day60)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour61,
                                                    minute: minute61,
                                                    second: second61,
                                                    nanosecond: nanosecond61,
                                                } = time59;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour61)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute61)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second61)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond61);
                                                *base.add(28).cast::<i32>() = _rt::as_i32(offset58);
                                            }
                                            Tstzbound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end53 {
                                            Tstzbound::Included(e) => {
                                                *base.add(32).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp62,
                                                    offset: offset62,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date63,
                                                    time: time63,
                                                } = timestamp62;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year64,
                                                    month: month64,
                                                    day: day64,
                                                } = date63;
                                                *base.add(36).cast::<i32>() = _rt::as_i32(year64);
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(month64)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(day64)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour65,
                                                    minute: minute65,
                                                    second: second65,
                                                    nanosecond: nanosecond65,
                                                } = time63;
                                                *base.add(44).cast::<u8>() = (_rt::as_i32(hour65)) as u8;
                                                *base.add(45).cast::<u8>() = (_rt::as_i32(minute65)) as u8;
                                                *base.add(46).cast::<u8>() = (_rt::as_i32(second65)) as u8;
                                                *base.add(48).cast::<i32>() = _rt::as_i32(nanosecond65);
                                                *base.add(52).cast::<i32>() = _rt::as_i32(offset62);
                                            }
                                            Tstzbound::Excluded(e) => {
                                                *base.add(32).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp66,
                                                    offset: offset66,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date67,
                                                    time: time67,
                                                } = timestamp66;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year68,
                                                    month: month68,
                                                    day: day68,
                                                } = date67;
                                                *base.add(36).cast::<i32>() = _rt::as_i32(year68);
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(month68)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(day68)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour69,
                                                    minute: minute69,
                                                    second: second69,
                                                    nanosecond: nanosecond69,
                                                } = time67;
                                                *base.add(44).cast::<u8>() = (_rt::as_i32(hour69)) as u8;
                                                *base.add(45).cast::<u8>() = (_rt::as_i32(minute69)) as u8;
                                                *base.add(46).cast::<u8>() = (_rt::as_i32(second69)) as u8;
                                                *base.add(48).cast::<i32>() = _rt::as_i32(nanosecond69);
                                                *base.add(52).cast::<i32>() = _rt::as_i32(offset66);
                                            }
                                            Tstzbound::Unbounded => {
                                                *base.add(32).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Daterange(e) => {
                                        *base.add(0).cast::<u8>() = (33i32) as u8;
                                        let Daterange { start: start70, end: end70 } = e;
                                        match start70 {
                                            Datebound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year71,
                                                    month: month71,
                                                    day: day71,
                                                } = e;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year71);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month71)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day71)) as u8;
                                            }
                                            Datebound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year72,
                                                    month: month72,
                                                    day: day72,
                                                } = e;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year72);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month72)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day72)) as u8;
                                            }
                                            Datebound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end70 {
                                            Datebound::Included(e) => {
                                                *base.add(20).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year73,
                                                    month: month73,
                                                    day: day73,
                                                } = e;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(year73);
                                                *base.add(28).cast::<u8>() = (_rt::as_i32(month73)) as u8;
                                                *base.add(29).cast::<u8>() = (_rt::as_i32(day73)) as u8;
                                            }
                                            Datebound::Excluded(e) => {
                                                *base.add(20).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year74,
                                                    month: month74,
                                                    day: day74,
                                                } = e;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(year74);
                                                *base.add(28).cast::<u8>() = (_rt::as_i32(month74)) as u8;
                                                *base.add(29).cast::<u8>() = (_rt::as_i32(day74)) as u8;
                                            }
                                            Datebound::Unbounded => {
                                                *base.add(20).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Money(e) => {
                                        *base.add(0).cast::<u8>() = (34i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::Oid(e) => {
                                        *base.add(0).cast::<u8>() = (35i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Enumeration(e) => {
                                        *base.add(0).cast::<u8>() = (36i32) as u8;
                                        let Enumeration { name: name75, value: value75 } = e;
                                        let vec76 = name75;
                                        let ptr76 = vec76.as_ptr().cast::<u8>();
                                        let len76 = vec76.len();
                                        *base.add(12).cast::<usize>() = len76;
                                        *base.add(8).cast::<*mut u8>() = ptr76.cast_mut();
                                        let vec77 = value75;
                                        let ptr77 = vec77.as_ptr().cast::<u8>();
                                        let len77 = vec77.len();
                                        *base.add(20).cast::<usize>() = len77;
                                        *base.add(16).cast::<*mut u8>() = ptr77.cast_mut();
                                    }
                                    DbValue::Composite(e) => {
                                        *base.add(0).cast::<u8>() = (37i32) as u8;
                                        let Composite { name: name78, values: values78 } = e;
                                        let vec79 = name78;
                                        let ptr79 = vec79.as_ptr().cast::<u8>();
                                        let len79 = vec79.len();
                                        *base.add(12).cast::<usize>() = len79;
                                        *base.add(8).cast::<*mut u8>() = ptr79.cast_mut();
                                        let vec80 = values78;
                                        let len80 = vec80.len();
                                        let layout80 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec80.len() * 4,
                                            4,
                                        );
                                        let result80 = if layout80.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout80).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout80);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec80.into_iter().enumerate() {
                                            let base = result80.add(i * 4);
                                            {
                                                *base.add(0).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                        }
                                        *base.add(20).cast::<usize>() = len80;
                                        *base.add(16).cast::<*mut u8>() = result80;
                                        cleanup_list.extend_from_slice(&[(result80, layout80)]);
                                    }
                                    DbValue::Domain(e) => {
                                        *base.add(0).cast::<u8>() = (38i32) as u8;
                                        let Domain { name: name81, value: value81 } = e;
                                        let vec82 = name81;
                                        let ptr82 = vec82.as_ptr().cast::<u8>();
                                        let len82 = vec82.len();
                                        *base.add(12).cast::<usize>() = len82;
                                        *base.add(8).cast::<*mut u8>() = ptr82.cast_mut();
                                        *base.add(16).cast::<i32>() = (value81).take_handle()
                                            as i32;
                                    }
                                    DbValue::Array(e) => {
                                        *base.add(0).cast::<u8>() = (39i32) as u8;
                                        let vec83 = e;
                                        let len83 = vec83.len();
                                        let layout83 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec83.len() * 4,
                                            4,
                                        );
                                        let result83 = if layout83.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout83).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout83);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec83.into_iter().enumerate() {
                                            let base = result83.add(i * 4);
                                            {
                                                *base.add(0).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len83;
                                        *base.add(8).cast::<*mut u8>() = result83;
                                        cleanup_list.extend_from_slice(&[(result83, layout83)]);
                                    }
                                    DbValue::Range(e) => {
                                        *base.add(0).cast::<u8>() = (40i32) as u8;
                                        let Range { name: name84, value: value84 } = e;
                                        let vec85 = name84;
                                        let ptr85 = vec85.as_ptr().cast::<u8>();
                                        let len85 = vec85.len();
                                        *base.add(12).cast::<usize>() = len85;
                                        *base.add(8).cast::<*mut u8>() = ptr85.cast_mut();
                                        let ValuesRange { start: start86, end: end86 } = value84;
                                        match start86 {
                                            ValueBound::Included(e) => {
                                                *base.add(16).cast::<u8>() = (0i32) as u8;
                                                *base.add(20).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Excluded(e) => {
                                                *base.add(16).cast::<u8>() = (1i32) as u8;
                                                *base.add(20).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Unbounded => {
                                                *base.add(16).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end86 {
                                            ValueBound::Included(e) => {
                                                *base.add(24).cast::<u8>() = (0i32) as u8;
                                                *base.add(28).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Excluded(e) => {
                                                *base.add(24).cast::<u8>() = (1i32) as u8;
                                                *base.add(28).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Unbounded => {
                                                *base.add(24).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Null => {
                                        *base.add(0).cast::<u8>() = (41i32) as u8;
                                    }
                                }
                            }
                        }
                        let ptr88 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rdbms/postgres@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-connection.query"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            result87,
                            len87,
                            ptr88,
                        );
                        let l89 = i32::from(*ptr88.add(0).cast::<u8>());
                        if layout87.size() != 0 {
                            _rt::alloc::dealloc(result87.cast(), layout87);
                        }
                        for (ptr, layout) in cleanup_list {
                            if layout.size() != 0 {
                                _rt::alloc::dealloc(ptr.cast(), layout);
                            }
                        }
                        match l89 {
                            0 => {
                                let e = {
                                    let l90 = *ptr88.add(4).cast::<*mut u8>();
                                    let l91 = *ptr88.add(8).cast::<usize>();
                                    let base123 = l90;
                                    let len123 = l91;
                                    let mut result123 = _rt::Vec::with_capacity(len123);
                                    for i in 0..len123 {
                                        let base = base123.add(i * 48);
                                        let e123 = {
                                            let l92 = *base.add(0).cast::<i64>();
                                            let l93 = *base.add(8).cast::<*mut u8>();
                                            let l94 = *base.add(12).cast::<usize>();
                                            let len95 = l94;
                                            let bytes95 = _rt::Vec::from_raw_parts(
                                                l93.cast(),
                                                len95,
                                                len95,
                                            );
                                            let l96 = i32::from(*base.add(16).cast::<u8>());
                                            let v119 = match l96 {
                                                0 => DbColumnType::Character,
                                                1 => DbColumnType::Int2,
                                                2 => DbColumnType::Int4,
                                                3 => DbColumnType::Int8,
                                                4 => DbColumnType::Float4,
                                                5 => DbColumnType::Float8,
                                                6 => DbColumnType::Numeric,
                                                7 => DbColumnType::Boolean,
                                                8 => DbColumnType::Text,
                                                9 => DbColumnType::Varchar,
                                                10 => DbColumnType::Bpchar,
                                                11 => DbColumnType::Timestamp,
                                                12 => DbColumnType::Timestamptz,
                                                13 => DbColumnType::Date,
                                                14 => DbColumnType::Time,
                                                15 => DbColumnType::Timetz,
                                                16 => DbColumnType::Interval,
                                                17 => DbColumnType::Bytea,
                                                18 => DbColumnType::Uuid,
                                                19 => DbColumnType::Xml,
                                                20 => DbColumnType::Json,
                                                21 => DbColumnType::Jsonb,
                                                22 => DbColumnType::Jsonpath,
                                                23 => DbColumnType::Inet,
                                                24 => DbColumnType::Cidr,
                                                25 => DbColumnType::Macaddr,
                                                26 => DbColumnType::Bit,
                                                27 => DbColumnType::Varbit,
                                                28 => DbColumnType::Int4range,
                                                29 => DbColumnType::Int8range,
                                                30 => DbColumnType::Numrange,
                                                31 => DbColumnType::Tsrange,
                                                32 => DbColumnType::Tstzrange,
                                                33 => DbColumnType::Daterange,
                                                34 => DbColumnType::Money,
                                                35 => DbColumnType::Oid,
                                                36 => {
                                                    let e119 = {
                                                        let l97 = *base.add(20).cast::<*mut u8>();
                                                        let l98 = *base.add(24).cast::<usize>();
                                                        let len99 = l98;
                                                        let bytes99 = _rt::Vec::from_raw_parts(
                                                            l97.cast(),
                                                            len99,
                                                            len99,
                                                        );
                                                        EnumerationType {
                                                            name: _rt::string_lift(bytes99),
                                                        }
                                                    };
                                                    DbColumnType::Enumeration(e119)
                                                }
                                                37 => {
                                                    let e119 = {
                                                        let l100 = *base.add(20).cast::<*mut u8>();
                                                        let l101 = *base.add(24).cast::<usize>();
                                                        let len102 = l101;
                                                        let bytes102 = _rt::Vec::from_raw_parts(
                                                            l100.cast(),
                                                            len102,
                                                            len102,
                                                        );
                                                        let l103 = *base.add(28).cast::<*mut u8>();
                                                        let l104 = *base.add(32).cast::<usize>();
                                                        let base109 = l103;
                                                        let len109 = l104;
                                                        let mut result109 = _rt::Vec::with_capacity(len109);
                                                        for i in 0..len109 {
                                                            let base = base109.add(i * 12);
                                                            let e109 = {
                                                                let l105 = *base.add(0).cast::<*mut u8>();
                                                                let l106 = *base.add(4).cast::<usize>();
                                                                let len107 = l106;
                                                                let bytes107 = _rt::Vec::from_raw_parts(
                                                                    l105.cast(),
                                                                    len107,
                                                                    len107,
                                                                );
                                                                let l108 = *base.add(8).cast::<i32>();
                                                                (
                                                                    _rt::string_lift(bytes107),
                                                                    LazyDbColumnType::from_handle(l108 as u32),
                                                                )
                                                            };
                                                            result109.push(e109);
                                                        }
                                                        _rt::cabi_dealloc(base109, len109 * 12, 4);
                                                        CompositeType {
                                                            name: _rt::string_lift(bytes102),
                                                            attributes: result109,
                                                        }
                                                    };
                                                    DbColumnType::Composite(e119)
                                                }
                                                38 => {
                                                    let e119 = {
                                                        let l110 = *base.add(20).cast::<*mut u8>();
                                                        let l111 = *base.add(24).cast::<usize>();
                                                        let len112 = l111;
                                                        let bytes112 = _rt::Vec::from_raw_parts(
                                                            l110.cast(),
                                                            len112,
                                                            len112,
                                                        );
                                                        let l113 = *base.add(28).cast::<i32>();
                                                        DomainType {
                                                            name: _rt::string_lift(bytes112),
                                                            base_type: LazyDbColumnType::from_handle(l113 as u32),
                                                        }
                                                    };
                                                    DbColumnType::Domain(e119)
                                                }
                                                39 => {
                                                    let e119 = {
                                                        let l114 = *base.add(20).cast::<i32>();
                                                        LazyDbColumnType::from_handle(l114 as u32)
                                                    };
                                                    DbColumnType::Array(e119)
                                                }
                                                n => {
                                                    debug_assert_eq!(n, 40, "invalid enum discriminant");
                                                    let e119 = {
                                                        let l115 = *base.add(20).cast::<*mut u8>();
                                                        let l116 = *base.add(24).cast::<usize>();
                                                        let len117 = l116;
                                                        let bytes117 = _rt::Vec::from_raw_parts(
                                                            l115.cast(),
                                                            len117,
                                                            len117,
                                                        );
                                                        let l118 = *base.add(28).cast::<i32>();
                                                        RangeType {
                                                            name: _rt::string_lift(bytes117),
                                                            base_type: LazyDbColumnType::from_handle(l118 as u32),
                                                        }
                                                    };
                                                    DbColumnType::Range(e119)
                                                }
                                            };
                                            let l120 = *base.add(36).cast::<*mut u8>();
                                            let l121 = *base.add(40).cast::<usize>();
                                            let len122 = l121;
                                            let bytes122 = _rt::Vec::from_raw_parts(
                                                l120.cast(),
                                                len122,
                                                len122,
                                            );
                                            DbColumn {
                                                ordinal: l92 as u64,
                                                name: _rt::string_lift(bytes95),
                                                db_type: v119,
                                                db_type_name: _rt::string_lift(bytes122),
                                            }
                                        };
                                        result123.push(e123);
                                    }
                                    _rt::cabi_dealloc(base123, len123 * 48, 8);
                                    let l124 = *ptr88.add(12).cast::<*mut u8>();
                                    let l125 = *ptr88.add(16).cast::<usize>();
                                    let base389 = l124;
                                    let len389 = l125;
                                    let mut result389 = _rt::Vec::with_capacity(len389);
                                    for i in 0..len389 {
                                        let base = base389.add(i * 8);
                                        let e389 = {
                                            let l126 = *base.add(0).cast::<*mut u8>();
                                            let l127 = *base.add(4).cast::<usize>();
                                            let base388 = l126;
                                            let len388 = l127;
                                            let mut result388 = _rt::Vec::with_capacity(len388);
                                            for i in 0..len388 {
                                                let base = base388.add(i * 56);
                                                let e388 = {
                                                    let l128 = i32::from(*base.add(0).cast::<u8>());
                                                    let v387 = match l128 {
                                                        0 => {
                                                            let e387 = {
                                                                let l129 = i32::from(*base.add(8).cast::<i8>());
                                                                l129 as i8
                                                            };
                                                            DbValue::Character(e387)
                                                        }
                                                        1 => {
                                                            let e387 = {
                                                                let l130 = i32::from(*base.add(8).cast::<i16>());
                                                                l130 as i16
                                                            };
                                                            DbValue::Int2(e387)
                                                        }
                                                        2 => {
                                                            let e387 = {
                                                                let l131 = *base.add(8).cast::<i32>();
                                                                l131
                                                            };
                                                            DbValue::Int4(e387)
                                                        }
                                                        3 => {
                                                            let e387 = {
                                                                let l132 = *base.add(8).cast::<i64>();
                                                                l132
                                                            };
                                                            DbValue::Int8(e387)
                                                        }
                                                        4 => {
                                                            let e387 = {
                                                                let l133 = *base.add(8).cast::<f32>();
                                                                l133
                                                            };
                                                            DbValue::Float4(e387)
                                                        }
                                                        5 => {
                                                            let e387 = {
                                                                let l134 = *base.add(8).cast::<f64>();
                                                                l134
                                                            };
                                                            DbValue::Float8(e387)
                                                        }
                                                        6 => {
                                                            let e387 = {
                                                                let l135 = *base.add(8).cast::<*mut u8>();
                                                                let l136 = *base.add(12).cast::<usize>();
                                                                let len137 = l136;
                                                                let bytes137 = _rt::Vec::from_raw_parts(
                                                                    l135.cast(),
                                                                    len137,
                                                                    len137,
                                                                );
                                                                _rt::string_lift(bytes137)
                                                            };
                                                            DbValue::Numeric(e387)
                                                        }
                                                        7 => {
                                                            let e387 = {
                                                                let l138 = i32::from(*base.add(8).cast::<u8>());
                                                                _rt::bool_lift(l138 as u8)
                                                            };
                                                            DbValue::Boolean(e387)
                                                        }
                                                        8 => {
                                                            let e387 = {
                                                                let l139 = *base.add(8).cast::<*mut u8>();
                                                                let l140 = *base.add(12).cast::<usize>();
                                                                let len141 = l140;
                                                                let bytes141 = _rt::Vec::from_raw_parts(
                                                                    l139.cast(),
                                                                    len141,
                                                                    len141,
                                                                );
                                                                _rt::string_lift(bytes141)
                                                            };
                                                            DbValue::Text(e387)
                                                        }
                                                        9 => {
                                                            let e387 = {
                                                                let l142 = *base.add(8).cast::<*mut u8>();
                                                                let l143 = *base.add(12).cast::<usize>();
                                                                let len144 = l143;
                                                                let bytes144 = _rt::Vec::from_raw_parts(
                                                                    l142.cast(),
                                                                    len144,
                                                                    len144,
                                                                );
                                                                _rt::string_lift(bytes144)
                                                            };
                                                            DbValue::Varchar(e387)
                                                        }
                                                        10 => {
                                                            let e387 = {
                                                                let l145 = *base.add(8).cast::<*mut u8>();
                                                                let l146 = *base.add(12).cast::<usize>();
                                                                let len147 = l146;
                                                                let bytes147 = _rt::Vec::from_raw_parts(
                                                                    l145.cast(),
                                                                    len147,
                                                                    len147,
                                                                );
                                                                _rt::string_lift(bytes147)
                                                            };
                                                            DbValue::Bpchar(e387)
                                                        }
                                                        11 => {
                                                            let e387 = {
                                                                let l148 = *base.add(8).cast::<i32>();
                                                                let l149 = i32::from(*base.add(12).cast::<u8>());
                                                                let l150 = i32::from(*base.add(13).cast::<u8>());
                                                                let l151 = i32::from(*base.add(16).cast::<u8>());
                                                                let l152 = i32::from(*base.add(17).cast::<u8>());
                                                                let l153 = i32::from(*base.add(18).cast::<u8>());
                                                                let l154 = *base.add(20).cast::<i32>();
                                                                super::super::super::golem::rdbms::types::Timestamp {
                                                                    date: super::super::super::golem::rdbms::types::Date {
                                                                        year: l148,
                                                                        month: l149 as u8,
                                                                        day: l150 as u8,
                                                                    },
                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                        hour: l151 as u8,
                                                                        minute: l152 as u8,
                                                                        second: l153 as u8,
                                                                        nanosecond: l154 as u32,
                                                                    },
                                                                }
                                                            };
                                                            DbValue::Timestamp(e387)
                                                        }
                                                        12 => {
                                                            let e387 = {
                                                                let l155 = *base.add(8).cast::<i32>();
                                                                let l156 = i32::from(*base.add(12).cast::<u8>());
                                                                let l157 = i32::from(*base.add(13).cast::<u8>());
                                                                let l158 = i32::from(*base.add(16).cast::<u8>());
                                                                let l159 = i32::from(*base.add(17).cast::<u8>());
                                                                let l160 = i32::from(*base.add(18).cast::<u8>());
                                                                let l161 = *base.add(20).cast::<i32>();
                                                                let l162 = *base.add(24).cast::<i32>();
                                                                super::super::super::golem::rdbms::types::Timestamptz {
                                                                    timestamp: super::super::super::golem::rdbms::types::Timestamp {
                                                                        date: super::super::super::golem::rdbms::types::Date {
                                                                            year: l155,
                                                                            month: l156 as u8,
                                                                            day: l157 as u8,
                                                                        },
                                                                        time: super::super::super::golem::rdbms::types::Time {
                                                                            hour: l158 as u8,
                                                                            minute: l159 as u8,
                                                                            second: l160 as u8,
                                                                            nanosecond: l161 as u32,
                                                                        },
                                                                    },
                                                                    offset: l162,
                                                                }
                                                            };
                                                            DbValue::Timestamptz(e387)
                                                        }
                                                        13 => {
                                                            let e387 = {
                                                                let l163 = *base.add(8).cast::<i32>();
                                                                let l164 = i32::from(*base.add(12).cast::<u8>());
                                                                let l165 = i32::from(*base.add(13).cast::<u8>());
                                                                super::super::super::golem::rdbms::types::Date {
                                                                    year: l163,
                                                                    month: l164 as u8,
                                                                    day: l165 as u8,
                                                                }
                                                            };
                                                            DbValue::Date(e387)
                                                        }
                                                        14 => {
                                                            let e387 = {
                                                                let l166 = i32::from(*base.add(8).cast::<u8>());
                                                                let l167 = i32::from(*base.add(9).cast::<u8>());
                                                                let l168 = i32::from(*base.add(10).cast::<u8>());
                                                                let l169 = *base.add(12).cast::<i32>();
                                                                super::super::super::golem::rdbms::types::Time {
                                                                    hour: l166 as u8,
                                                                    minute: l167 as u8,
                                                                    second: l168 as u8,
                                                                    nanosecond: l169 as u32,
                                                                }
                                                            };
                                                            DbValue::Time(e387)
                                                        }
                                                        15 => {
                                                            let e387 = {
                                                                let l170 = i32::from(*base.add(8).cast::<u8>());
                                                                let l171 = i32::from(*base.add(9).cast::<u8>());
                                                                let l172 = i32::from(*base.add(10).cast::<u8>());
                                                                let l173 = *base.add(12).cast::<i32>();
                                                                let l174 = *base.add(16).cast::<i32>();
                                                                super::super::super::golem::rdbms::types::Timetz {
                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                        hour: l170 as u8,
                                                                        minute: l171 as u8,
                                                                        second: l172 as u8,
                                                                        nanosecond: l173 as u32,
                                                                    },
                                                                    offset: l174,
                                                                }
                                                            };
                                                            DbValue::Timetz(e387)
                                                        }
                                                        16 => {
                                                            let e387 = {
                                                                let l175 = *base.add(8).cast::<i32>();
                                                                let l176 = *base.add(12).cast::<i32>();
                                                                let l177 = *base.add(16).cast::<i64>();
                                                                Interval {
                                                                    months: l175,
                                                                    days: l176,
                                                                    microseconds: l177,
                                                                }
                                                            };
                                                            DbValue::Interval(e387)
                                                        }
                                                        17 => {
                                                            let e387 = {
                                                                let l178 = *base.add(8).cast::<*mut u8>();
                                                                let l179 = *base.add(12).cast::<usize>();
                                                                let len180 = l179;
                                                                _rt::Vec::from_raw_parts(l178.cast(), len180, len180)
                                                            };
                                                            DbValue::Bytea(e387)
                                                        }
                                                        18 => {
                                                            let e387 = {
                                                                let l181 = *base.add(8).cast::<*mut u8>();
                                                                let l182 = *base.add(12).cast::<usize>();
                                                                let len183 = l182;
                                                                let bytes183 = _rt::Vec::from_raw_parts(
                                                                    l181.cast(),
                                                                    len183,
                                                                    len183,
                                                                );
                                                                _rt::string_lift(bytes183)
                                                            };
                                                            DbValue::Json(e387)
                                                        }
                                                        19 => {
                                                            let e387 = {
                                                                let l184 = *base.add(8).cast::<*mut u8>();
                                                                let l185 = *base.add(12).cast::<usize>();
                                                                let len186 = l185;
                                                                let bytes186 = _rt::Vec::from_raw_parts(
                                                                    l184.cast(),
                                                                    len186,
                                                                    len186,
                                                                );
                                                                _rt::string_lift(bytes186)
                                                            };
                                                            DbValue::Jsonb(e387)
                                                        }
                                                        20 => {
                                                            let e387 = {
                                                                let l187 = *base.add(8).cast::<*mut u8>();
                                                                let l188 = *base.add(12).cast::<usize>();
                                                                let len189 = l188;
                                                                let bytes189 = _rt::Vec::from_raw_parts(
                                                                    l187.cast(),
                                                                    len189,
                                                                    len189,
                                                                );
                                                                _rt::string_lift(bytes189)
                                                            };
                                                            DbValue::Jsonpath(e387)
                                                        }
                                                        21 => {
                                                            let e387 = {
                                                                let l190 = *base.add(8).cast::<*mut u8>();
                                                                let l191 = *base.add(12).cast::<usize>();
                                                                let len192 = l191;
                                                                let bytes192 = _rt::Vec::from_raw_parts(
                                                                    l190.cast(),
                                                                    len192,
                                                                    len192,
                                                                );
                                                                _rt::string_lift(bytes192)
                                                            };
                                                            DbValue::Xml(e387)
                                                        }
                                                        22 => {
                                                            let e387 = {
                                                                let l193 = *base.add(8).cast::<i64>();
                                                                let l194 = *base.add(16).cast::<i64>();
                                                                super::super::super::golem::rdbms::types::Uuid {
                                                                    high_bits: l193 as u64,
                                                                    low_bits: l194 as u64,
                                                                }
                                                            };
                                                            DbValue::Uuid(e387)
                                                        }
                                                        23 => {
                                                            let e387 = {
                                                                let l195 = i32::from(*base.add(8).cast::<u8>());
                                                                use super::super::super::golem::rdbms::types::IpAddress as V208;
                                                                let v208 = match l195 {
                                                                    0 => {
                                                                        let e208 = {
                                                                            let l196 = i32::from(*base.add(10).cast::<u8>());
                                                                            let l197 = i32::from(*base.add(11).cast::<u8>());
                                                                            let l198 = i32::from(*base.add(12).cast::<u8>());
                                                                            let l199 = i32::from(*base.add(13).cast::<u8>());
                                                                            (l196 as u8, l197 as u8, l198 as u8, l199 as u8)
                                                                        };
                                                                        V208::Ipv4(e208)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 1, "invalid enum discriminant");
                                                                        let e208 = {
                                                                            let l200 = i32::from(*base.add(10).cast::<u16>());
                                                                            let l201 = i32::from(*base.add(12).cast::<u16>());
                                                                            let l202 = i32::from(*base.add(14).cast::<u16>());
                                                                            let l203 = i32::from(*base.add(16).cast::<u16>());
                                                                            let l204 = i32::from(*base.add(18).cast::<u16>());
                                                                            let l205 = i32::from(*base.add(20).cast::<u16>());
                                                                            let l206 = i32::from(*base.add(22).cast::<u16>());
                                                                            let l207 = i32::from(*base.add(24).cast::<u16>());
                                                                            (
                                                                                l200 as u16,
                                                                                l201 as u16,
                                                                                l202 as u16,
                                                                                l203 as u16,
                                                                                l204 as u16,
                                                                                l205 as u16,
                                                                                l206 as u16,
                                                                                l207 as u16,
                                                                            )
                                                                        };
                                                                        V208::Ipv6(e208)
                                                                    }
                                                                };
                                                                v208
                                                            };
                                                            DbValue::Inet(e387)
                                                        }
                                                        24 => {
                                                            let e387 = {
                                                                let l209 = i32::from(*base.add(8).cast::<u8>());
                                                                use super::super::super::golem::rdbms::types::IpAddress as V222;
                                                                let v222 = match l209 {
                                                                    0 => {
                                                                        let e222 = {
                                                                            let l210 = i32::from(*base.add(10).cast::<u8>());
                                                                            let l211 = i32::from(*base.add(11).cast::<u8>());
                                                                            let l212 = i32::from(*base.add(12).cast::<u8>());
                                                                            let l213 = i32::from(*base.add(13).cast::<u8>());
                                                                            (l210 as u8, l211 as u8, l212 as u8, l213 as u8)
                                                                        };
                                                                        V222::Ipv4(e222)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 1, "invalid enum discriminant");
                                                                        let e222 = {
                                                                            let l214 = i32::from(*base.add(10).cast::<u16>());
                                                                            let l215 = i32::from(*base.add(12).cast::<u16>());
                                                                            let l216 = i32::from(*base.add(14).cast::<u16>());
                                                                            let l217 = i32::from(*base.add(16).cast::<u16>());
                                                                            let l218 = i32::from(*base.add(18).cast::<u16>());
                                                                            let l219 = i32::from(*base.add(20).cast::<u16>());
                                                                            let l220 = i32::from(*base.add(22).cast::<u16>());
                                                                            let l221 = i32::from(*base.add(24).cast::<u16>());
                                                                            (
                                                                                l214 as u16,
                                                                                l215 as u16,
                                                                                l216 as u16,
                                                                                l217 as u16,
                                                                                l218 as u16,
                                                                                l219 as u16,
                                                                                l220 as u16,
                                                                                l221 as u16,
                                                                            )
                                                                        };
                                                                        V222::Ipv6(e222)
                                                                    }
                                                                };
                                                                v222
                                                            };
                                                            DbValue::Cidr(e387)
                                                        }
                                                        25 => {
                                                            let e387 = {
                                                                let l223 = i32::from(*base.add(8).cast::<u8>());
                                                                let l224 = i32::from(*base.add(9).cast::<u8>());
                                                                let l225 = i32::from(*base.add(10).cast::<u8>());
                                                                let l226 = i32::from(*base.add(11).cast::<u8>());
                                                                let l227 = i32::from(*base.add(12).cast::<u8>());
                                                                let l228 = i32::from(*base.add(13).cast::<u8>());
                                                                super::super::super::golem::rdbms::types::MacAddress {
                                                                    octets: (
                                                                        l223 as u8,
                                                                        l224 as u8,
                                                                        l225 as u8,
                                                                        l226 as u8,
                                                                        l227 as u8,
                                                                        l228 as u8,
                                                                    ),
                                                                }
                                                            };
                                                            DbValue::Macaddr(e387)
                                                        }
                                                        26 => {
                                                            let e387 = {
                                                                let l229 = *base.add(8).cast::<*mut u8>();
                                                                let l230 = *base.add(12).cast::<usize>();
                                                                let base232 = l229;
                                                                let len232 = l230;
                                                                let mut result232 = _rt::Vec::with_capacity(len232);
                                                                for i in 0..len232 {
                                                                    let base = base232.add(i * 1);
                                                                    let e232 = {
                                                                        let l231 = i32::from(*base.add(0).cast::<u8>());
                                                                        _rt::bool_lift(l231 as u8)
                                                                    };
                                                                    result232.push(e232);
                                                                }
                                                                _rt::cabi_dealloc(base232, len232 * 1, 1);
                                                                result232
                                                            };
                                                            DbValue::Bit(e387)
                                                        }
                                                        27 => {
                                                            let e387 = {
                                                                let l233 = *base.add(8).cast::<*mut u8>();
                                                                let l234 = *base.add(12).cast::<usize>();
                                                                let base236 = l233;
                                                                let len236 = l234;
                                                                let mut result236 = _rt::Vec::with_capacity(len236);
                                                                for i in 0..len236 {
                                                                    let base = base236.add(i * 1);
                                                                    let e236 = {
                                                                        let l235 = i32::from(*base.add(0).cast::<u8>());
                                                                        _rt::bool_lift(l235 as u8)
                                                                    };
                                                                    result236.push(e236);
                                                                }
                                                                _rt::cabi_dealloc(base236, len236 * 1, 1);
                                                                result236
                                                            };
                                                            DbValue::Varbit(e387)
                                                        }
                                                        28 => {
                                                            let e387 = {
                                                                let l237 = i32::from(*base.add(8).cast::<u8>());
                                                                let v240 = match l237 {
                                                                    0 => {
                                                                        let e240 = {
                                                                            let l238 = *base.add(12).cast::<i32>();
                                                                            l238
                                                                        };
                                                                        Int4bound::Included(e240)
                                                                    }
                                                                    1 => {
                                                                        let e240 = {
                                                                            let l239 = *base.add(12).cast::<i32>();
                                                                            l239
                                                                        };
                                                                        Int4bound::Excluded(e240)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Int4bound::Unbounded
                                                                    }
                                                                };
                                                                let l241 = i32::from(*base.add(16).cast::<u8>());
                                                                let v244 = match l241 {
                                                                    0 => {
                                                                        let e244 = {
                                                                            let l242 = *base.add(20).cast::<i32>();
                                                                            l242
                                                                        };
                                                                        Int4bound::Included(e244)
                                                                    }
                                                                    1 => {
                                                                        let e244 = {
                                                                            let l243 = *base.add(20).cast::<i32>();
                                                                            l243
                                                                        };
                                                                        Int4bound::Excluded(e244)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Int4bound::Unbounded
                                                                    }
                                                                };
                                                                Int4range {
                                                                    start: v240,
                                                                    end: v244,
                                                                }
                                                            };
                                                            DbValue::Int4range(e387)
                                                        }
                                                        29 => {
                                                            let e387 = {
                                                                let l245 = i32::from(*base.add(8).cast::<u8>());
                                                                let v248 = match l245 {
                                                                    0 => {
                                                                        let e248 = {
                                                                            let l246 = *base.add(16).cast::<i64>();
                                                                            l246
                                                                        };
                                                                        Int8bound::Included(e248)
                                                                    }
                                                                    1 => {
                                                                        let e248 = {
                                                                            let l247 = *base.add(16).cast::<i64>();
                                                                            l247
                                                                        };
                                                                        Int8bound::Excluded(e248)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Int8bound::Unbounded
                                                                    }
                                                                };
                                                                let l249 = i32::from(*base.add(24).cast::<u8>());
                                                                let v252 = match l249 {
                                                                    0 => {
                                                                        let e252 = {
                                                                            let l250 = *base.add(32).cast::<i64>();
                                                                            l250
                                                                        };
                                                                        Int8bound::Included(e252)
                                                                    }
                                                                    1 => {
                                                                        let e252 = {
                                                                            let l251 = *base.add(32).cast::<i64>();
                                                                            l251
                                                                        };
                                                                        Int8bound::Excluded(e252)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Int8bound::Unbounded
                                                                    }
                                                                };
                                                                Int8range {
                                                                    start: v248,
                                                                    end: v252,
                                                                }
                                                            };
                                                            DbValue::Int8range(e387)
                                                        }
                                                        30 => {
                                                            let e387 = {
                                                                let l253 = i32::from(*base.add(8).cast::<u8>());
                                                                let v260 = match l253 {
                                                                    0 => {
                                                                        let e260 = {
                                                                            let l254 = *base.add(12).cast::<*mut u8>();
                                                                            let l255 = *base.add(16).cast::<usize>();
                                                                            let len256 = l255;
                                                                            let bytes256 = _rt::Vec::from_raw_parts(
                                                                                l254.cast(),
                                                                                len256,
                                                                                len256,
                                                                            );
                                                                            _rt::string_lift(bytes256)
                                                                        };
                                                                        Numbound::Included(e260)
                                                                    }
                                                                    1 => {
                                                                        let e260 = {
                                                                            let l257 = *base.add(12).cast::<*mut u8>();
                                                                            let l258 = *base.add(16).cast::<usize>();
                                                                            let len259 = l258;
                                                                            let bytes259 = _rt::Vec::from_raw_parts(
                                                                                l257.cast(),
                                                                                len259,
                                                                                len259,
                                                                            );
                                                                            _rt::string_lift(bytes259)
                                                                        };
                                                                        Numbound::Excluded(e260)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Numbound::Unbounded
                                                                    }
                                                                };
                                                                let l261 = i32::from(*base.add(20).cast::<u8>());
                                                                let v268 = match l261 {
                                                                    0 => {
                                                                        let e268 = {
                                                                            let l262 = *base.add(24).cast::<*mut u8>();
                                                                            let l263 = *base.add(28).cast::<usize>();
                                                                            let len264 = l263;
                                                                            let bytes264 = _rt::Vec::from_raw_parts(
                                                                                l262.cast(),
                                                                                len264,
                                                                                len264,
                                                                            );
                                                                            _rt::string_lift(bytes264)
                                                                        };
                                                                        Numbound::Included(e268)
                                                                    }
                                                                    1 => {
                                                                        let e268 = {
                                                                            let l265 = *base.add(24).cast::<*mut u8>();
                                                                            let l266 = *base.add(28).cast::<usize>();
                                                                            let len267 = l266;
                                                                            let bytes267 = _rt::Vec::from_raw_parts(
                                                                                l265.cast(),
                                                                                len267,
                                                                                len267,
                                                                            );
                                                                            _rt::string_lift(bytes267)
                                                                        };
                                                                        Numbound::Excluded(e268)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Numbound::Unbounded
                                                                    }
                                                                };
                                                                Numrange { start: v260, end: v268 }
                                                            };
                                                            DbValue::Numrange(e387)
                                                        }
                                                        31 => {
                                                            let e387 = {
                                                                let l269 = i32::from(*base.add(8).cast::<u8>());
                                                                let v284 = match l269 {
                                                                    0 => {
                                                                        let e284 = {
                                                                            let l270 = *base.add(12).cast::<i32>();
                                                                            let l271 = i32::from(*base.add(16).cast::<u8>());
                                                                            let l272 = i32::from(*base.add(17).cast::<u8>());
                                                                            let l273 = i32::from(*base.add(20).cast::<u8>());
                                                                            let l274 = i32::from(*base.add(21).cast::<u8>());
                                                                            let l275 = i32::from(*base.add(22).cast::<u8>());
                                                                            let l276 = *base.add(24).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamp {
                                                                                date: super::super::super::golem::rdbms::types::Date {
                                                                                    year: l270,
                                                                                    month: l271 as u8,
                                                                                    day: l272 as u8,
                                                                                },
                                                                                time: super::super::super::golem::rdbms::types::Time {
                                                                                    hour: l273 as u8,
                                                                                    minute: l274 as u8,
                                                                                    second: l275 as u8,
                                                                                    nanosecond: l276 as u32,
                                                                                },
                                                                            }
                                                                        };
                                                                        Tsbound::Included(e284)
                                                                    }
                                                                    1 => {
                                                                        let e284 = {
                                                                            let l277 = *base.add(12).cast::<i32>();
                                                                            let l278 = i32::from(*base.add(16).cast::<u8>());
                                                                            let l279 = i32::from(*base.add(17).cast::<u8>());
                                                                            let l280 = i32::from(*base.add(20).cast::<u8>());
                                                                            let l281 = i32::from(*base.add(21).cast::<u8>());
                                                                            let l282 = i32::from(*base.add(22).cast::<u8>());
                                                                            let l283 = *base.add(24).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamp {
                                                                                date: super::super::super::golem::rdbms::types::Date {
                                                                                    year: l277,
                                                                                    month: l278 as u8,
                                                                                    day: l279 as u8,
                                                                                },
                                                                                time: super::super::super::golem::rdbms::types::Time {
                                                                                    hour: l280 as u8,
                                                                                    minute: l281 as u8,
                                                                                    second: l282 as u8,
                                                                                    nanosecond: l283 as u32,
                                                                                },
                                                                            }
                                                                        };
                                                                        Tsbound::Excluded(e284)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Tsbound::Unbounded
                                                                    }
                                                                };
                                                                let l285 = i32::from(*base.add(28).cast::<u8>());
                                                                let v300 = match l285 {
                                                                    0 => {
                                                                        let e300 = {
                                                                            let l286 = *base.add(32).cast::<i32>();
                                                                            let l287 = i32::from(*base.add(36).cast::<u8>());
                                                                            let l288 = i32::from(*base.add(37).cast::<u8>());
                                                                            let l289 = i32::from(*base.add(40).cast::<u8>());
                                                                            let l290 = i32::from(*base.add(41).cast::<u8>());
                                                                            let l291 = i32::from(*base.add(42).cast::<u8>());
                                                                            let l292 = *base.add(44).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamp {
                                                                                date: super::super::super::golem::rdbms::types::Date {
                                                                                    year: l286,
                                                                                    month: l287 as u8,
                                                                                    day: l288 as u8,
                                                                                },
                                                                                time: super::super::super::golem::rdbms::types::Time {
                                                                                    hour: l289 as u8,
                                                                                    minute: l290 as u8,
                                                                                    second: l291 as u8,
                                                                                    nanosecond: l292 as u32,
                                                                                },
                                                                            }
                                                                        };
                                                                        Tsbound::Included(e300)
                                                                    }
                                                                    1 => {
                                                                        let e300 = {
                                                                            let l293 = *base.add(32).cast::<i32>();
                                                                            let l294 = i32::from(*base.add(36).cast::<u8>());
                                                                            let l295 = i32::from(*base.add(37).cast::<u8>());
                                                                            let l296 = i32::from(*base.add(40).cast::<u8>());
                                                                            let l297 = i32::from(*base.add(41).cast::<u8>());
                                                                            let l298 = i32::from(*base.add(42).cast::<u8>());
                                                                            let l299 = *base.add(44).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamp {
                                                                                date: super::super::super::golem::rdbms::types::Date {
                                                                                    year: l293,
                                                                                    month: l294 as u8,
                                                                                    day: l295 as u8,
                                                                                },
                                                                                time: super::super::super::golem::rdbms::types::Time {
                                                                                    hour: l296 as u8,
                                                                                    minute: l297 as u8,
                                                                                    second: l298 as u8,
                                                                                    nanosecond: l299 as u32,
                                                                                },
                                                                            }
                                                                        };
                                                                        Tsbound::Excluded(e300)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Tsbound::Unbounded
                                                                    }
                                                                };
                                                                Tsrange { start: v284, end: v300 }
                                                            };
                                                            DbValue::Tsrange(e387)
                                                        }
                                                        32 => {
                                                            let e387 = {
                                                                let l301 = i32::from(*base.add(8).cast::<u8>());
                                                                let v318 = match l301 {
                                                                    0 => {
                                                                        let e318 = {
                                                                            let l302 = *base.add(12).cast::<i32>();
                                                                            let l303 = i32::from(*base.add(16).cast::<u8>());
                                                                            let l304 = i32::from(*base.add(17).cast::<u8>());
                                                                            let l305 = i32::from(*base.add(20).cast::<u8>());
                                                                            let l306 = i32::from(*base.add(21).cast::<u8>());
                                                                            let l307 = i32::from(*base.add(22).cast::<u8>());
                                                                            let l308 = *base.add(24).cast::<i32>();
                                                                            let l309 = *base.add(28).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamptz {
                                                                                timestamp: super::super::super::golem::rdbms::types::Timestamp {
                                                                                    date: super::super::super::golem::rdbms::types::Date {
                                                                                        year: l302,
                                                                                        month: l303 as u8,
                                                                                        day: l304 as u8,
                                                                                    },
                                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                                        hour: l305 as u8,
                                                                                        minute: l306 as u8,
                                                                                        second: l307 as u8,
                                                                                        nanosecond: l308 as u32,
                                                                                    },
                                                                                },
                                                                                offset: l309,
                                                                            }
                                                                        };
                                                                        Tstzbound::Included(e318)
                                                                    }
                                                                    1 => {
                                                                        let e318 = {
                                                                            let l310 = *base.add(12).cast::<i32>();
                                                                            let l311 = i32::from(*base.add(16).cast::<u8>());
                                                                            let l312 = i32::from(*base.add(17).cast::<u8>());
                                                                            let l313 = i32::from(*base.add(20).cast::<u8>());
                                                                            let l314 = i32::from(*base.add(21).cast::<u8>());
                                                                            let l315 = i32::from(*base.add(22).cast::<u8>());
                                                                            let l316 = *base.add(24).cast::<i32>();
                                                                            let l317 = *base.add(28).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamptz {
                                                                                timestamp: super::super::super::golem::rdbms::types::Timestamp {
                                                                                    date: super::super::super::golem::rdbms::types::Date {
                                                                                        year: l310,
                                                                                        month: l311 as u8,
                                                                                        day: l312 as u8,
                                                                                    },
                                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                                        hour: l313 as u8,
                                                                                        minute: l314 as u8,
                                                                                        second: l315 as u8,
                                                                                        nanosecond: l316 as u32,
                                                                                    },
                                                                                },
                                                                                offset: l317,
                                                                            }
                                                                        };
                                                                        Tstzbound::Excluded(e318)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Tstzbound::Unbounded
                                                                    }
                                                                };
                                                                let l319 = i32::from(*base.add(32).cast::<u8>());
                                                                let v336 = match l319 {
                                                                    0 => {
                                                                        let e336 = {
                                                                            let l320 = *base.add(36).cast::<i32>();
                                                                            let l321 = i32::from(*base.add(40).cast::<u8>());
                                                                            let l322 = i32::from(*base.add(41).cast::<u8>());
                                                                            let l323 = i32::from(*base.add(44).cast::<u8>());
                                                                            let l324 = i32::from(*base.add(45).cast::<u8>());
                                                                            let l325 = i32::from(*base.add(46).cast::<u8>());
                                                                            let l326 = *base.add(48).cast::<i32>();
                                                                            let l327 = *base.add(52).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamptz {
                                                                                timestamp: super::super::super::golem::rdbms::types::Timestamp {
                                                                                    date: super::super::super::golem::rdbms::types::Date {
                                                                                        year: l320,
                                                                                        month: l321 as u8,
                                                                                        day: l322 as u8,
                                                                                    },
                                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                                        hour: l323 as u8,
                                                                                        minute: l324 as u8,
                                                                                        second: l325 as u8,
                                                                                        nanosecond: l326 as u32,
                                                                                    },
                                                                                },
                                                                                offset: l327,
                                                                            }
                                                                        };
                                                                        Tstzbound::Included(e336)
                                                                    }
                                                                    1 => {
                                                                        let e336 = {
                                                                            let l328 = *base.add(36).cast::<i32>();
                                                                            let l329 = i32::from(*base.add(40).cast::<u8>());
                                                                            let l330 = i32::from(*base.add(41).cast::<u8>());
                                                                            let l331 = i32::from(*base.add(44).cast::<u8>());
                                                                            let l332 = i32::from(*base.add(45).cast::<u8>());
                                                                            let l333 = i32::from(*base.add(46).cast::<u8>());
                                                                            let l334 = *base.add(48).cast::<i32>();
                                                                            let l335 = *base.add(52).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamptz {
                                                                                timestamp: super::super::super::golem::rdbms::types::Timestamp {
                                                                                    date: super::super::super::golem::rdbms::types::Date {
                                                                                        year: l328,
                                                                                        month: l329 as u8,
                                                                                        day: l330 as u8,
                                                                                    },
                                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                                        hour: l331 as u8,
                                                                                        minute: l332 as u8,
                                                                                        second: l333 as u8,
                                                                                        nanosecond: l334 as u32,
                                                                                    },
                                                                                },
                                                                                offset: l335,
                                                                            }
                                                                        };
                                                                        Tstzbound::Excluded(e336)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Tstzbound::Unbounded
                                                                    }
                                                                };
                                                                Tstzrange {
                                                                    start: v318,
                                                                    end: v336,
                                                                }
                                                            };
                                                            DbValue::Tstzrange(e387)
                                                        }
                                                        33 => {
                                                            let e387 = {
                                                                let l337 = i32::from(*base.add(8).cast::<u8>());
                                                                let v344 = match l337 {
                                                                    0 => {
                                                                        let e344 = {
                                                                            let l338 = *base.add(12).cast::<i32>();
                                                                            let l339 = i32::from(*base.add(16).cast::<u8>());
                                                                            let l340 = i32::from(*base.add(17).cast::<u8>());
                                                                            super::super::super::golem::rdbms::types::Date {
                                                                                year: l338,
                                                                                month: l339 as u8,
                                                                                day: l340 as u8,
                                                                            }
                                                                        };
                                                                        Datebound::Included(e344)
                                                                    }
                                                                    1 => {
                                                                        let e344 = {
                                                                            let l341 = *base.add(12).cast::<i32>();
                                                                            let l342 = i32::from(*base.add(16).cast::<u8>());
                                                                            let l343 = i32::from(*base.add(17).cast::<u8>());
                                                                            super::super::super::golem::rdbms::types::Date {
                                                                                year: l341,
                                                                                month: l342 as u8,
                                                                                day: l343 as u8,
                                                                            }
                                                                        };
                                                                        Datebound::Excluded(e344)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Datebound::Unbounded
                                                                    }
                                                                };
                                                                let l345 = i32::from(*base.add(20).cast::<u8>());
                                                                let v352 = match l345 {
                                                                    0 => {
                                                                        let e352 = {
                                                                            let l346 = *base.add(24).cast::<i32>();
                                                                            let l347 = i32::from(*base.add(28).cast::<u8>());
                                                                            let l348 = i32::from(*base.add(29).cast::<u8>());
                                                                            super::super::super::golem::rdbms::types::Date {
                                                                                year: l346,
                                                                                month: l347 as u8,
                                                                                day: l348 as u8,
                                                                            }
                                                                        };
                                                                        Datebound::Included(e352)
                                                                    }
                                                                    1 => {
                                                                        let e352 = {
                                                                            let l349 = *base.add(24).cast::<i32>();
                                                                            let l350 = i32::from(*base.add(28).cast::<u8>());
                                                                            let l351 = i32::from(*base.add(29).cast::<u8>());
                                                                            super::super::super::golem::rdbms::types::Date {
                                                                                year: l349,
                                                                                month: l350 as u8,
                                                                                day: l351 as u8,
                                                                            }
                                                                        };
                                                                        Datebound::Excluded(e352)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Datebound::Unbounded
                                                                    }
                                                                };
                                                                Daterange {
                                                                    start: v344,
                                                                    end: v352,
                                                                }
                                                            };
                                                            DbValue::Daterange(e387)
                                                        }
                                                        34 => {
                                                            let e387 = {
                                                                let l353 = *base.add(8).cast::<i64>();
                                                                l353
                                                            };
                                                            DbValue::Money(e387)
                                                        }
                                                        35 => {
                                                            let e387 = {
                                                                let l354 = *base.add(8).cast::<i32>();
                                                                l354 as u32
                                                            };
                                                            DbValue::Oid(e387)
                                                        }
                                                        36 => {
                                                            let e387 = {
                                                                let l355 = *base.add(8).cast::<*mut u8>();
                                                                let l356 = *base.add(12).cast::<usize>();
                                                                let len357 = l356;
                                                                let bytes357 = _rt::Vec::from_raw_parts(
                                                                    l355.cast(),
                                                                    len357,
                                                                    len357,
                                                                );
                                                                let l358 = *base.add(16).cast::<*mut u8>();
                                                                let l359 = *base.add(20).cast::<usize>();
                                                                let len360 = l359;
                                                                let bytes360 = _rt::Vec::from_raw_parts(
                                                                    l358.cast(),
                                                                    len360,
                                                                    len360,
                                                                );
                                                                Enumeration {
                                                                    name: _rt::string_lift(bytes357),
                                                                    value: _rt::string_lift(bytes360),
                                                                }
                                                            };
                                                            DbValue::Enumeration(e387)
                                                        }
                                                        37 => {
                                                            let e387 = {
                                                                let l361 = *base.add(8).cast::<*mut u8>();
                                                                let l362 = *base.add(12).cast::<usize>();
                                                                let len363 = l362;
                                                                let bytes363 = _rt::Vec::from_raw_parts(
                                                                    l361.cast(),
                                                                    len363,
                                                                    len363,
                                                                );
                                                                let l364 = *base.add(16).cast::<*mut u8>();
                                                                let l365 = *base.add(20).cast::<usize>();
                                                                let base367 = l364;
                                                                let len367 = l365;
                                                                let mut result367 = _rt::Vec::with_capacity(len367);
                                                                for i in 0..len367 {
                                                                    let base = base367.add(i * 4);
                                                                    let e367 = {
                                                                        let l366 = *base.add(0).cast::<i32>();
                                                                        LazyDbValue::from_handle(l366 as u32)
                                                                    };
                                                                    result367.push(e367);
                                                                }
                                                                _rt::cabi_dealloc(base367, len367 * 4, 4);
                                                                Composite {
                                                                    name: _rt::string_lift(bytes363),
                                                                    values: result367,
                                                                }
                                                            };
                                                            DbValue::Composite(e387)
                                                        }
                                                        38 => {
                                                            let e387 = {
                                                                let l368 = *base.add(8).cast::<*mut u8>();
                                                                let l369 = *base.add(12).cast::<usize>();
                                                                let len370 = l369;
                                                                let bytes370 = _rt::Vec::from_raw_parts(
                                                                    l368.cast(),
                                                                    len370,
                                                                    len370,
                                                                );
                                                                let l371 = *base.add(16).cast::<i32>();
                                                                Domain {
                                                                    name: _rt::string_lift(bytes370),
                                                                    value: LazyDbValue::from_handle(l371 as u32),
                                                                }
                                                            };
                                                            DbValue::Domain(e387)
                                                        }
                                                        39 => {
                                                            let e387 = {
                                                                let l372 = *base.add(8).cast::<*mut u8>();
                                                                let l373 = *base.add(12).cast::<usize>();
                                                                let base375 = l372;
                                                                let len375 = l373;
                                                                let mut result375 = _rt::Vec::with_capacity(len375);
                                                                for i in 0..len375 {
                                                                    let base = base375.add(i * 4);
                                                                    let e375 = {
                                                                        let l374 = *base.add(0).cast::<i32>();
                                                                        LazyDbValue::from_handle(l374 as u32)
                                                                    };
                                                                    result375.push(e375);
                                                                }
                                                                _rt::cabi_dealloc(base375, len375 * 4, 4);
                                                                result375
                                                            };
                                                            DbValue::Array(e387)
                                                        }
                                                        40 => {
                                                            let e387 = {
                                                                let l376 = *base.add(8).cast::<*mut u8>();
                                                                let l377 = *base.add(12).cast::<usize>();
                                                                let len378 = l377;
                                                                let bytes378 = _rt::Vec::from_raw_parts(
                                                                    l376.cast(),
                                                                    len378,
                                                                    len378,
                                                                );
                                                                let l379 = i32::from(*base.add(16).cast::<u8>());
                                                                let v382 = match l379 {
                                                                    0 => {
                                                                        let e382 = {
                                                                            let l380 = *base.add(20).cast::<i32>();
                                                                            LazyDbValue::from_handle(l380 as u32)
                                                                        };
                                                                        ValueBound::Included(e382)
                                                                    }
                                                                    1 => {
                                                                        let e382 = {
                                                                            let l381 = *base.add(20).cast::<i32>();
                                                                            LazyDbValue::from_handle(l381 as u32)
                                                                        };
                                                                        ValueBound::Excluded(e382)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        ValueBound::Unbounded
                                                                    }
                                                                };
                                                                let l383 = i32::from(*base.add(24).cast::<u8>());
                                                                let v386 = match l383 {
                                                                    0 => {
                                                                        let e386 = {
                                                                            let l384 = *base.add(28).cast::<i32>();
                                                                            LazyDbValue::from_handle(l384 as u32)
                                                                        };
                                                                        ValueBound::Included(e386)
                                                                    }
                                                                    1 => {
                                                                        let e386 = {
                                                                            let l385 = *base.add(28).cast::<i32>();
                                                                            LazyDbValue::from_handle(l385 as u32)
                                                                        };
                                                                        ValueBound::Excluded(e386)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        ValueBound::Unbounded
                                                                    }
                                                                };
                                                                Range {
                                                                    name: _rt::string_lift(bytes378),
                                                                    value: ValuesRange {
                                                                        start: v382,
                                                                        end: v386,
                                                                    },
                                                                }
                                                            };
                                                            DbValue::Range(e387)
                                                        }
                                                        n => {
                                                            debug_assert_eq!(n, 41, "invalid enum discriminant");
                                                            DbValue::Null
                                                        }
                                                    };
                                                    v387
                                                };
                                                result388.push(e388);
                                            }
                                            _rt::cabi_dealloc(base388, len388 * 56, 8);
                                            DbRow { values: result388 }
                                        };
                                        result389.push(e389);
                                    }
                                    _rt::cabi_dealloc(base389, len389 * 8, 4);
                                    DbResult {
                                        columns: result123,
                                        rows: result389,
                                    }
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l390 = i32::from(*ptr88.add(4).cast::<u8>());
                                    let v406 = match l390 {
                                        0 => {
                                            let e406 = {
                                                let l391 = *ptr88.add(8).cast::<*mut u8>();
                                                let l392 = *ptr88.add(12).cast::<usize>();
                                                let len393 = l392;
                                                let bytes393 = _rt::Vec::from_raw_parts(
                                                    l391.cast(),
                                                    len393,
                                                    len393,
                                                );
                                                _rt::string_lift(bytes393)
                                            };
                                            Error::ConnectionFailure(e406)
                                        }
                                        1 => {
                                            let e406 = {
                                                let l394 = *ptr88.add(8).cast::<*mut u8>();
                                                let l395 = *ptr88.add(12).cast::<usize>();
                                                let len396 = l395;
                                                let bytes396 = _rt::Vec::from_raw_parts(
                                                    l394.cast(),
                                                    len396,
                                                    len396,
                                                );
                                                _rt::string_lift(bytes396)
                                            };
                                            Error::QueryParameterFailure(e406)
                                        }
                                        2 => {
                                            let e406 = {
                                                let l397 = *ptr88.add(8).cast::<*mut u8>();
                                                let l398 = *ptr88.add(12).cast::<usize>();
                                                let len399 = l398;
                                                let bytes399 = _rt::Vec::from_raw_parts(
                                                    l397.cast(),
                                                    len399,
                                                    len399,
                                                );
                                                _rt::string_lift(bytes399)
                                            };
                                            Error::QueryExecutionFailure(e406)
                                        }
                                        3 => {
                                            let e406 = {
                                                let l400 = *ptr88.add(8).cast::<*mut u8>();
                                                let l401 = *ptr88.add(12).cast::<usize>();
                                                let len402 = l401;
                                                let bytes402 = _rt::Vec::from_raw_parts(
                                                    l400.cast(),
                                                    len402,
                                                    len402,
                                                );
                                                _rt::string_lift(bytes402)
                                            };
                                            Error::QueryResponseFailure(e406)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 4, "invalid enum discriminant");
                                            let e406 = {
                                                let l403 = *ptr88.add(8).cast::<*mut u8>();
                                                let l404 = *ptr88.add(12).cast::<usize>();
                                                let len405 = l404;
                                                let bytes405 = _rt::Vec::from_raw_parts(
                                                    l403.cast(),
                                                    len405,
                                                    len405,
                                                );
                                                _rt::string_lift(bytes405)
                                            };
                                            Error::Other(e406)
                                        }
                                    };
                                    v406
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl DbConnection {
                #[allow(unused_unsafe, clippy::all)]
                pub fn query_stream(
                    &self,
                    statement: &str,
                    params: _rt::Vec<DbValue>,
                ) -> Result<DbResultStream, Error> {
                    unsafe {
                        let mut cleanup_list = _rt::Vec::new();
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 16]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 16],
                        );
                        let vec0 = statement;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let vec87 = &params;
                        let len87 = vec87.len();
                        let layout87 = _rt::alloc::Layout::from_size_align_unchecked(
                            vec87.len() * 56,
                            8,
                        );
                        let result87 = if layout87.size() != 0 {
                            let ptr = _rt::alloc::alloc(layout87).cast::<u8>();
                            if ptr.is_null() {
                                _rt::alloc::handle_alloc_error(layout87);
                            }
                            ptr
                        } else {
                            ::core::ptr::null_mut()
                        };
                        for (i, e) in vec87.into_iter().enumerate() {
                            let base = result87.add(i * 56);
                            {
                                match e {
                                    DbValue::Character(e) => {
                                        *base.add(0).cast::<u8>() = (0i32) as u8;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                    }
                                    DbValue::Int2(e) => {
                                        *base.add(0).cast::<u8>() = (1i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::Int4(e) => {
                                        *base.add(0).cast::<u8>() = (2i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Int8(e) => {
                                        *base.add(0).cast::<u8>() = (3i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::Float4(e) => {
                                        *base.add(0).cast::<u8>() = (4i32) as u8;
                                        *base.add(8).cast::<f32>() = _rt::as_f32(e);
                                    }
                                    DbValue::Float8(e) => {
                                        *base.add(0).cast::<u8>() = (5i32) as u8;
                                        *base.add(8).cast::<f64>() = _rt::as_f64(e);
                                    }
                                    DbValue::Numeric(e) => {
                                        *base.add(0).cast::<u8>() = (6i32) as u8;
                                        let vec1 = e;
                                        let ptr1 = vec1.as_ptr().cast::<u8>();
                                        let len1 = vec1.len();
                                        *base.add(12).cast::<usize>() = len1;
                                        *base.add(8).cast::<*mut u8>() = ptr1.cast_mut();
                                    }
                                    DbValue::Boolean(e) => {
                                        *base.add(0).cast::<u8>() = (7i32) as u8;
                                        *base.add(8).cast::<u8>() = (match e {
                                            true => 1,
                                            false => 0,
                                        }) as u8;
                                    }
                                    DbValue::Text(e) => {
                                        *base.add(0).cast::<u8>() = (8i32) as u8;
                                        let vec2 = e;
                                        let ptr2 = vec2.as_ptr().cast::<u8>();
                                        let len2 = vec2.len();
                                        *base.add(12).cast::<usize>() = len2;
                                        *base.add(8).cast::<*mut u8>() = ptr2.cast_mut();
                                    }
                                    DbValue::Varchar(e) => {
                                        *base.add(0).cast::<u8>() = (9i32) as u8;
                                        let vec3 = e;
                                        let ptr3 = vec3.as_ptr().cast::<u8>();
                                        let len3 = vec3.len();
                                        *base.add(12).cast::<usize>() = len3;
                                        *base.add(8).cast::<*mut u8>() = ptr3.cast_mut();
                                    }
                                    DbValue::Bpchar(e) => {
                                        *base.add(0).cast::<u8>() = (10i32) as u8;
                                        let vec4 = e;
                                        let ptr4 = vec4.as_ptr().cast::<u8>();
                                        let len4 = vec4.len();
                                        *base.add(12).cast::<usize>() = len4;
                                        *base.add(8).cast::<*mut u8>() = ptr4.cast_mut();
                                    }
                                    DbValue::Timestamp(e) => {
                                        *base.add(0).cast::<u8>() = (11i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date5,
                                            time: time5,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year6,
                                            month: month6,
                                            day: day6,
                                        } = date5;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year6);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month6)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day6)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour7,
                                            minute: minute7,
                                            second: second7,
                                            nanosecond: nanosecond7,
                                        } = time5;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour7)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute7)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second7)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond7);
                                    }
                                    DbValue::Timestamptz(e) => {
                                        *base.add(0).cast::<u8>() = (12i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamptz {
                                            timestamp: timestamp8,
                                            offset: offset8,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date9,
                                            time: time9,
                                        } = timestamp8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year10,
                                            month: month10,
                                            day: day10,
                                        } = date9;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year10);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month10)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day10)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour11,
                                            minute: minute11,
                                            second: second11,
                                            nanosecond: nanosecond11,
                                        } = time9;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour11)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute11)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second11)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond11);
                                        *base.add(24).cast::<i32>() = _rt::as_i32(offset8);
                                    }
                                    DbValue::Date(e) => {
                                        *base.add(0).cast::<u8>() = (13i32) as u8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year12,
                                            month: month12,
                                            day: day12,
                                        } = e;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year12);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month12)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day12)) as u8;
                                    }
                                    DbValue::Time(e) => {
                                        *base.add(0).cast::<u8>() = (14i32) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour13,
                                            minute: minute13,
                                            second: second13,
                                            nanosecond: nanosecond13,
                                        } = e;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(hour13)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(minute13)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(second13)) as u8;
                                        *base.add(12).cast::<i32>() = _rt::as_i32(nanosecond13);
                                    }
                                    DbValue::Timetz(e) => {
                                        *base.add(0).cast::<u8>() = (15i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timetz {
                                            time: time14,
                                            offset: offset14,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour15,
                                            minute: minute15,
                                            second: second15,
                                            nanosecond: nanosecond15,
                                        } = time14;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(hour15)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(minute15)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(second15)) as u8;
                                        *base.add(12).cast::<i32>() = _rt::as_i32(nanosecond15);
                                        *base.add(16).cast::<i32>() = _rt::as_i32(offset14);
                                    }
                                    DbValue::Interval(e) => {
                                        *base.add(0).cast::<u8>() = (16i32) as u8;
                                        let Interval {
                                            months: months16,
                                            days: days16,
                                            microseconds: microseconds16,
                                        } = e;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(months16);
                                        *base.add(12).cast::<i32>() = _rt::as_i32(days16);
                                        *base.add(16).cast::<i64>() = _rt::as_i64(microseconds16);
                                    }
                                    DbValue::Bytea(e) => {
                                        *base.add(0).cast::<u8>() = (17i32) as u8;
                                        let vec17 = e;
                                        let ptr17 = vec17.as_ptr().cast::<u8>();
                                        let len17 = vec17.len();
                                        *base.add(12).cast::<usize>() = len17;
                                        *base.add(8).cast::<*mut u8>() = ptr17.cast_mut();
                                    }
                                    DbValue::Json(e) => {
                                        *base.add(0).cast::<u8>() = (18i32) as u8;
                                        let vec18 = e;
                                        let ptr18 = vec18.as_ptr().cast::<u8>();
                                        let len18 = vec18.len();
                                        *base.add(12).cast::<usize>() = len18;
                                        *base.add(8).cast::<*mut u8>() = ptr18.cast_mut();
                                    }
                                    DbValue::Jsonb(e) => {
                                        *base.add(0).cast::<u8>() = (19i32) as u8;
                                        let vec19 = e;
                                        let ptr19 = vec19.as_ptr().cast::<u8>();
                                        let len19 = vec19.len();
                                        *base.add(12).cast::<usize>() = len19;
                                        *base.add(8).cast::<*mut u8>() = ptr19.cast_mut();
                                    }
                                    DbValue::Jsonpath(e) => {
                                        *base.add(0).cast::<u8>() = (20i32) as u8;
                                        let vec20 = e;
                                        let ptr20 = vec20.as_ptr().cast::<u8>();
                                        let len20 = vec20.len();
                                        *base.add(12).cast::<usize>() = len20;
                                        *base.add(8).cast::<*mut u8>() = ptr20.cast_mut();
                                    }
                                    DbValue::Xml(e) => {
                                        *base.add(0).cast::<u8>() = (21i32) as u8;
                                        let vec21 = e;
                                        let ptr21 = vec21.as_ptr().cast::<u8>();
                                        let len21 = vec21.len();
                                        *base.add(12).cast::<usize>() = len21;
                                        *base.add(8).cast::<*mut u8>() = ptr21.cast_mut();
                                    }
                                    DbValue::Uuid(e) => {
                                        *base.add(0).cast::<u8>() = (22i32) as u8;
                                        let super::super::super::golem::rdbms::types::Uuid {
                                            high_bits: high_bits22,
                                            low_bits: low_bits22,
                                        } = e;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(high_bits22);
                                        *base.add(16).cast::<i64>() = _rt::as_i64(low_bits22);
                                    }
                                    DbValue::Inet(e) => {
                                        *base.add(0).cast::<u8>() = (23i32) as u8;
                                        use super::super::super::golem::rdbms::types::IpAddress as V25;
                                        match e {
                                            V25::Ipv4(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let (t23_0, t23_1, t23_2, t23_3) = e;
                                                *base.add(10).cast::<u8>() = (_rt::as_i32(t23_0)) as u8;
                                                *base.add(11).cast::<u8>() = (_rt::as_i32(t23_1)) as u8;
                                                *base.add(12).cast::<u8>() = (_rt::as_i32(t23_2)) as u8;
                                                *base.add(13).cast::<u8>() = (_rt::as_i32(t23_3)) as u8;
                                            }
                                            V25::Ipv6(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let (
                                                    t24_0,
                                                    t24_1,
                                                    t24_2,
                                                    t24_3,
                                                    t24_4,
                                                    t24_5,
                                                    t24_6,
                                                    t24_7,
                                                ) = e;
                                                *base.add(10).cast::<u16>() = (_rt::as_i32(t24_0)) as u16;
                                                *base.add(12).cast::<u16>() = (_rt::as_i32(t24_1)) as u16;
                                                *base.add(14).cast::<u16>() = (_rt::as_i32(t24_2)) as u16;
                                                *base.add(16).cast::<u16>() = (_rt::as_i32(t24_3)) as u16;
                                                *base.add(18).cast::<u16>() = (_rt::as_i32(t24_4)) as u16;
                                                *base.add(20).cast::<u16>() = (_rt::as_i32(t24_5)) as u16;
                                                *base.add(22).cast::<u16>() = (_rt::as_i32(t24_6)) as u16;
                                                *base.add(24).cast::<u16>() = (_rt::as_i32(t24_7)) as u16;
                                            }
                                        }
                                    }
                                    DbValue::Cidr(e) => {
                                        *base.add(0).cast::<u8>() = (24i32) as u8;
                                        use super::super::super::golem::rdbms::types::IpAddress as V28;
                                        match e {
                                            V28::Ipv4(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let (t26_0, t26_1, t26_2, t26_3) = e;
                                                *base.add(10).cast::<u8>() = (_rt::as_i32(t26_0)) as u8;
                                                *base.add(11).cast::<u8>() = (_rt::as_i32(t26_1)) as u8;
                                                *base.add(12).cast::<u8>() = (_rt::as_i32(t26_2)) as u8;
                                                *base.add(13).cast::<u8>() = (_rt::as_i32(t26_3)) as u8;
                                            }
                                            V28::Ipv6(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let (
                                                    t27_0,
                                                    t27_1,
                                                    t27_2,
                                                    t27_3,
                                                    t27_4,
                                                    t27_5,
                                                    t27_6,
                                                    t27_7,
                                                ) = e;
                                                *base.add(10).cast::<u16>() = (_rt::as_i32(t27_0)) as u16;
                                                *base.add(12).cast::<u16>() = (_rt::as_i32(t27_1)) as u16;
                                                *base.add(14).cast::<u16>() = (_rt::as_i32(t27_2)) as u16;
                                                *base.add(16).cast::<u16>() = (_rt::as_i32(t27_3)) as u16;
                                                *base.add(18).cast::<u16>() = (_rt::as_i32(t27_4)) as u16;
                                                *base.add(20).cast::<u16>() = (_rt::as_i32(t27_5)) as u16;
                                                *base.add(22).cast::<u16>() = (_rt::as_i32(t27_6)) as u16;
                                                *base.add(24).cast::<u16>() = (_rt::as_i32(t27_7)) as u16;
                                            }
                                        }
                                    }
                                    DbValue::Macaddr(e) => {
                                        *base.add(0).cast::<u8>() = (25i32) as u8;
                                        let super::super::super::golem::rdbms::types::MacAddress {
                                            octets: octets29,
                                        } = e;
                                        let (t30_0, t30_1, t30_2, t30_3, t30_4, t30_5) = octets29;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(t30_0)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(t30_1)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(t30_2)) as u8;
                                        *base.add(11).cast::<u8>() = (_rt::as_i32(t30_3)) as u8;
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(t30_4)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(t30_5)) as u8;
                                    }
                                    DbValue::Bit(e) => {
                                        *base.add(0).cast::<u8>() = (26i32) as u8;
                                        let vec31 = e;
                                        let len31 = vec31.len();
                                        let layout31 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec31.len() * 1,
                                            1,
                                        );
                                        let result31 = if layout31.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout31).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout31);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec31.into_iter().enumerate() {
                                            let base = result31.add(i * 1);
                                            {
                                                *base.add(0).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len31;
                                        *base.add(8).cast::<*mut u8>() = result31;
                                        cleanup_list.extend_from_slice(&[(result31, layout31)]);
                                    }
                                    DbValue::Varbit(e) => {
                                        *base.add(0).cast::<u8>() = (27i32) as u8;
                                        let vec32 = e;
                                        let len32 = vec32.len();
                                        let layout32 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec32.len() * 1,
                                            1,
                                        );
                                        let result32 = if layout32.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout32).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout32);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec32.into_iter().enumerate() {
                                            let base = result32.add(i * 1);
                                            {
                                                *base.add(0).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len32;
                                        *base.add(8).cast::<*mut u8>() = result32;
                                        cleanup_list.extend_from_slice(&[(result32, layout32)]);
                                    }
                                    DbValue::Int4range(e) => {
                                        *base.add(0).cast::<u8>() = (28i32) as u8;
                                        let Int4range { start: start33, end: end33 } = e;
                                        match start33 {
                                            Int4bound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end33 {
                                            Int4bound::Included(e) => {
                                                *base.add(16).cast::<u8>() = (0i32) as u8;
                                                *base.add(20).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Excluded(e) => {
                                                *base.add(16).cast::<u8>() = (1i32) as u8;
                                                *base.add(20).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Unbounded => {
                                                *base.add(16).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Int8range(e) => {
                                        *base.add(0).cast::<u8>() = (29i32) as u8;
                                        let Int8range { start: start34, end: end34 } = e;
                                        match start34 {
                                            Int8bound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                *base.add(16).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                *base.add(16).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end34 {
                                            Int8bound::Included(e) => {
                                                *base.add(24).cast::<u8>() = (0i32) as u8;
                                                *base.add(32).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Excluded(e) => {
                                                *base.add(24).cast::<u8>() = (1i32) as u8;
                                                *base.add(32).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Unbounded => {
                                                *base.add(24).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Numrange(e) => {
                                        *base.add(0).cast::<u8>() = (30i32) as u8;
                                        let Numrange { start: start35, end: end35 } = e;
                                        match start35 {
                                            Numbound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let vec36 = e;
                                                let ptr36 = vec36.as_ptr().cast::<u8>();
                                                let len36 = vec36.len();
                                                *base.add(16).cast::<usize>() = len36;
                                                *base.add(12).cast::<*mut u8>() = ptr36.cast_mut();
                                            }
                                            Numbound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let vec37 = e;
                                                let ptr37 = vec37.as_ptr().cast::<u8>();
                                                let len37 = vec37.len();
                                                *base.add(16).cast::<usize>() = len37;
                                                *base.add(12).cast::<*mut u8>() = ptr37.cast_mut();
                                            }
                                            Numbound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end35 {
                                            Numbound::Included(e) => {
                                                *base.add(20).cast::<u8>() = (0i32) as u8;
                                                let vec38 = e;
                                                let ptr38 = vec38.as_ptr().cast::<u8>();
                                                let len38 = vec38.len();
                                                *base.add(28).cast::<usize>() = len38;
                                                *base.add(24).cast::<*mut u8>() = ptr38.cast_mut();
                                            }
                                            Numbound::Excluded(e) => {
                                                *base.add(20).cast::<u8>() = (1i32) as u8;
                                                let vec39 = e;
                                                let ptr39 = vec39.as_ptr().cast::<u8>();
                                                let len39 = vec39.len();
                                                *base.add(28).cast::<usize>() = len39;
                                                *base.add(24).cast::<*mut u8>() = ptr39.cast_mut();
                                            }
                                            Numbound::Unbounded => {
                                                *base.add(20).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Tsrange(e) => {
                                        *base.add(0).cast::<u8>() = (31i32) as u8;
                                        let Tsrange { start: start40, end: end40 } = e;
                                        match start40 {
                                            Tsbound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date41,
                                                    time: time41,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year42,
                                                    month: month42,
                                                    day: day42,
                                                } = date41;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year42);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month42)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day42)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour43,
                                                    minute: minute43,
                                                    second: second43,
                                                    nanosecond: nanosecond43,
                                                } = time41;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour43)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute43)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second43)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond43);
                                            }
                                            Tsbound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date44,
                                                    time: time44,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year45,
                                                    month: month45,
                                                    day: day45,
                                                } = date44;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year45);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month45)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day45)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour46,
                                                    minute: minute46,
                                                    second: second46,
                                                    nanosecond: nanosecond46,
                                                } = time44;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour46)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute46)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second46)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond46);
                                            }
                                            Tsbound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end40 {
                                            Tsbound::Included(e) => {
                                                *base.add(28).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date47,
                                                    time: time47,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year48,
                                                    month: month48,
                                                    day: day48,
                                                } = date47;
                                                *base.add(32).cast::<i32>() = _rt::as_i32(year48);
                                                *base.add(36).cast::<u8>() = (_rt::as_i32(month48)) as u8;
                                                *base.add(37).cast::<u8>() = (_rt::as_i32(day48)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour49,
                                                    minute: minute49,
                                                    second: second49,
                                                    nanosecond: nanosecond49,
                                                } = time47;
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(hour49)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(minute49)) as u8;
                                                *base.add(42).cast::<u8>() = (_rt::as_i32(second49)) as u8;
                                                *base.add(44).cast::<i32>() = _rt::as_i32(nanosecond49);
                                            }
                                            Tsbound::Excluded(e) => {
                                                *base.add(28).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date50,
                                                    time: time50,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year51,
                                                    month: month51,
                                                    day: day51,
                                                } = date50;
                                                *base.add(32).cast::<i32>() = _rt::as_i32(year51);
                                                *base.add(36).cast::<u8>() = (_rt::as_i32(month51)) as u8;
                                                *base.add(37).cast::<u8>() = (_rt::as_i32(day51)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour52,
                                                    minute: minute52,
                                                    second: second52,
                                                    nanosecond: nanosecond52,
                                                } = time50;
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(hour52)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(minute52)) as u8;
                                                *base.add(42).cast::<u8>() = (_rt::as_i32(second52)) as u8;
                                                *base.add(44).cast::<i32>() = _rt::as_i32(nanosecond52);
                                            }
                                            Tsbound::Unbounded => {
                                                *base.add(28).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Tstzrange(e) => {
                                        *base.add(0).cast::<u8>() = (32i32) as u8;
                                        let Tstzrange { start: start53, end: end53 } = e;
                                        match start53 {
                                            Tstzbound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp54,
                                                    offset: offset54,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date55,
                                                    time: time55,
                                                } = timestamp54;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year56,
                                                    month: month56,
                                                    day: day56,
                                                } = date55;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year56);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month56)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day56)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour57,
                                                    minute: minute57,
                                                    second: second57,
                                                    nanosecond: nanosecond57,
                                                } = time55;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour57)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute57)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second57)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond57);
                                                *base.add(28).cast::<i32>() = _rt::as_i32(offset54);
                                            }
                                            Tstzbound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp58,
                                                    offset: offset58,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date59,
                                                    time: time59,
                                                } = timestamp58;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year60,
                                                    month: month60,
                                                    day: day60,
                                                } = date59;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year60);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month60)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day60)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour61,
                                                    minute: minute61,
                                                    second: second61,
                                                    nanosecond: nanosecond61,
                                                } = time59;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour61)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute61)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second61)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond61);
                                                *base.add(28).cast::<i32>() = _rt::as_i32(offset58);
                                            }
                                            Tstzbound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end53 {
                                            Tstzbound::Included(e) => {
                                                *base.add(32).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp62,
                                                    offset: offset62,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date63,
                                                    time: time63,
                                                } = timestamp62;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year64,
                                                    month: month64,
                                                    day: day64,
                                                } = date63;
                                                *base.add(36).cast::<i32>() = _rt::as_i32(year64);
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(month64)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(day64)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour65,
                                                    minute: minute65,
                                                    second: second65,
                                                    nanosecond: nanosecond65,
                                                } = time63;
                                                *base.add(44).cast::<u8>() = (_rt::as_i32(hour65)) as u8;
                                                *base.add(45).cast::<u8>() = (_rt::as_i32(minute65)) as u8;
                                                *base.add(46).cast::<u8>() = (_rt::as_i32(second65)) as u8;
                                                *base.add(48).cast::<i32>() = _rt::as_i32(nanosecond65);
                                                *base.add(52).cast::<i32>() = _rt::as_i32(offset62);
                                            }
                                            Tstzbound::Excluded(e) => {
                                                *base.add(32).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp66,
                                                    offset: offset66,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date67,
                                                    time: time67,
                                                } = timestamp66;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year68,
                                                    month: month68,
                                                    day: day68,
                                                } = date67;
                                                *base.add(36).cast::<i32>() = _rt::as_i32(year68);
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(month68)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(day68)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour69,
                                                    minute: minute69,
                                                    second: second69,
                                                    nanosecond: nanosecond69,
                                                } = time67;
                                                *base.add(44).cast::<u8>() = (_rt::as_i32(hour69)) as u8;
                                                *base.add(45).cast::<u8>() = (_rt::as_i32(minute69)) as u8;
                                                *base.add(46).cast::<u8>() = (_rt::as_i32(second69)) as u8;
                                                *base.add(48).cast::<i32>() = _rt::as_i32(nanosecond69);
                                                *base.add(52).cast::<i32>() = _rt::as_i32(offset66);
                                            }
                                            Tstzbound::Unbounded => {
                                                *base.add(32).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Daterange(e) => {
                                        *base.add(0).cast::<u8>() = (33i32) as u8;
                                        let Daterange { start: start70, end: end70 } = e;
                                        match start70 {
                                            Datebound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year71,
                                                    month: month71,
                                                    day: day71,
                                                } = e;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year71);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month71)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day71)) as u8;
                                            }
                                            Datebound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year72,
                                                    month: month72,
                                                    day: day72,
                                                } = e;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year72);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month72)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day72)) as u8;
                                            }
                                            Datebound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end70 {
                                            Datebound::Included(e) => {
                                                *base.add(20).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year73,
                                                    month: month73,
                                                    day: day73,
                                                } = e;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(year73);
                                                *base.add(28).cast::<u8>() = (_rt::as_i32(month73)) as u8;
                                                *base.add(29).cast::<u8>() = (_rt::as_i32(day73)) as u8;
                                            }
                                            Datebound::Excluded(e) => {
                                                *base.add(20).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year74,
                                                    month: month74,
                                                    day: day74,
                                                } = e;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(year74);
                                                *base.add(28).cast::<u8>() = (_rt::as_i32(month74)) as u8;
                                                *base.add(29).cast::<u8>() = (_rt::as_i32(day74)) as u8;
                                            }
                                            Datebound::Unbounded => {
                                                *base.add(20).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Money(e) => {
                                        *base.add(0).cast::<u8>() = (34i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::Oid(e) => {
                                        *base.add(0).cast::<u8>() = (35i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Enumeration(e) => {
                                        *base.add(0).cast::<u8>() = (36i32) as u8;
                                        let Enumeration { name: name75, value: value75 } = e;
                                        let vec76 = name75;
                                        let ptr76 = vec76.as_ptr().cast::<u8>();
                                        let len76 = vec76.len();
                                        *base.add(12).cast::<usize>() = len76;
                                        *base.add(8).cast::<*mut u8>() = ptr76.cast_mut();
                                        let vec77 = value75;
                                        let ptr77 = vec77.as_ptr().cast::<u8>();
                                        let len77 = vec77.len();
                                        *base.add(20).cast::<usize>() = len77;
                                        *base.add(16).cast::<*mut u8>() = ptr77.cast_mut();
                                    }
                                    DbValue::Composite(e) => {
                                        *base.add(0).cast::<u8>() = (37i32) as u8;
                                        let Composite { name: name78, values: values78 } = e;
                                        let vec79 = name78;
                                        let ptr79 = vec79.as_ptr().cast::<u8>();
                                        let len79 = vec79.len();
                                        *base.add(12).cast::<usize>() = len79;
                                        *base.add(8).cast::<*mut u8>() = ptr79.cast_mut();
                                        let vec80 = values78;
                                        let len80 = vec80.len();
                                        let layout80 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec80.len() * 4,
                                            4,
                                        );
                                        let result80 = if layout80.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout80).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout80);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec80.into_iter().enumerate() {
                                            let base = result80.add(i * 4);
                                            {
                                                *base.add(0).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                        }
                                        *base.add(20).cast::<usize>() = len80;
                                        *base.add(16).cast::<*mut u8>() = result80;
                                        cleanup_list.extend_from_slice(&[(result80, layout80)]);
                                    }
                                    DbValue::Domain(e) => {
                                        *base.add(0).cast::<u8>() = (38i32) as u8;
                                        let Domain { name: name81, value: value81 } = e;
                                        let vec82 = name81;
                                        let ptr82 = vec82.as_ptr().cast::<u8>();
                                        let len82 = vec82.len();
                                        *base.add(12).cast::<usize>() = len82;
                                        *base.add(8).cast::<*mut u8>() = ptr82.cast_mut();
                                        *base.add(16).cast::<i32>() = (value81).take_handle()
                                            as i32;
                                    }
                                    DbValue::Array(e) => {
                                        *base.add(0).cast::<u8>() = (39i32) as u8;
                                        let vec83 = e;
                                        let len83 = vec83.len();
                                        let layout83 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec83.len() * 4,
                                            4,
                                        );
                                        let result83 = if layout83.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout83).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout83);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec83.into_iter().enumerate() {
                                            let base = result83.add(i * 4);
                                            {
                                                *base.add(0).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len83;
                                        *base.add(8).cast::<*mut u8>() = result83;
                                        cleanup_list.extend_from_slice(&[(result83, layout83)]);
                                    }
                                    DbValue::Range(e) => {
                                        *base.add(0).cast::<u8>() = (40i32) as u8;
                                        let Range { name: name84, value: value84 } = e;
                                        let vec85 = name84;
                                        let ptr85 = vec85.as_ptr().cast::<u8>();
                                        let len85 = vec85.len();
                                        *base.add(12).cast::<usize>() = len85;
                                        *base.add(8).cast::<*mut u8>() = ptr85.cast_mut();
                                        let ValuesRange { start: start86, end: end86 } = value84;
                                        match start86 {
                                            ValueBound::Included(e) => {
                                                *base.add(16).cast::<u8>() = (0i32) as u8;
                                                *base.add(20).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Excluded(e) => {
                                                *base.add(16).cast::<u8>() = (1i32) as u8;
                                                *base.add(20).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Unbounded => {
                                                *base.add(16).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end86 {
                                            ValueBound::Included(e) => {
                                                *base.add(24).cast::<u8>() = (0i32) as u8;
                                                *base.add(28).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Excluded(e) => {
                                                *base.add(24).cast::<u8>() = (1i32) as u8;
                                                *base.add(28).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Unbounded => {
                                                *base.add(24).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Null => {
                                        *base.add(0).cast::<u8>() = (41i32) as u8;
                                    }
                                }
                            }
                        }
                        let ptr88 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rdbms/postgres@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-connection.query-stream"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            result87,
                            len87,
                            ptr88,
                        );
                        let l89 = i32::from(*ptr88.add(0).cast::<u8>());
                        if layout87.size() != 0 {
                            _rt::alloc::dealloc(result87.cast(), layout87);
                        }
                        for (ptr, layout) in cleanup_list {
                            if layout.size() != 0 {
                                _rt::alloc::dealloc(ptr.cast(), layout);
                            }
                        }
                        match l89 {
                            0 => {
                                let e = {
                                    let l90 = *ptr88.add(4).cast::<i32>();
                                    DbResultStream::from_handle(l90 as u32)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l91 = i32::from(*ptr88.add(4).cast::<u8>());
                                    let v107 = match l91 {
                                        0 => {
                                            let e107 = {
                                                let l92 = *ptr88.add(8).cast::<*mut u8>();
                                                let l93 = *ptr88.add(12).cast::<usize>();
                                                let len94 = l93;
                                                let bytes94 = _rt::Vec::from_raw_parts(
                                                    l92.cast(),
                                                    len94,
                                                    len94,
                                                );
                                                _rt::string_lift(bytes94)
                                            };
                                            Error::ConnectionFailure(e107)
                                        }
                                        1 => {
                                            let e107 = {
                                                let l95 = *ptr88.add(8).cast::<*mut u8>();
                                                let l96 = *ptr88.add(12).cast::<usize>();
                                                let len97 = l96;
                                                let bytes97 = _rt::Vec::from_raw_parts(
                                                    l95.cast(),
                                                    len97,
                                                    len97,
                                                );
                                                _rt::string_lift(bytes97)
                                            };
                                            Error::QueryParameterFailure(e107)
                                        }
                                        2 => {
                                            let e107 = {
                                                let l98 = *ptr88.add(8).cast::<*mut u8>();
                                                let l99 = *ptr88.add(12).cast::<usize>();
                                                let len100 = l99;
                                                let bytes100 = _rt::Vec::from_raw_parts(
                                                    l98.cast(),
                                                    len100,
                                                    len100,
                                                );
                                                _rt::string_lift(bytes100)
                                            };
                                            Error::QueryExecutionFailure(e107)
                                        }
                                        3 => {
                                            let e107 = {
                                                let l101 = *ptr88.add(8).cast::<*mut u8>();
                                                let l102 = *ptr88.add(12).cast::<usize>();
                                                let len103 = l102;
                                                let bytes103 = _rt::Vec::from_raw_parts(
                                                    l101.cast(),
                                                    len103,
                                                    len103,
                                                );
                                                _rt::string_lift(bytes103)
                                            };
                                            Error::QueryResponseFailure(e107)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 4, "invalid enum discriminant");
                                            let e107 = {
                                                let l104 = *ptr88.add(8).cast::<*mut u8>();
                                                let l105 = *ptr88.add(12).cast::<usize>();
                                                let len106 = l105;
                                                let bytes106 = _rt::Vec::from_raw_parts(
                                                    l104.cast(),
                                                    len106,
                                                    len106,
                                                );
                                                _rt::string_lift(bytes106)
                                            };
                                            Error::Other(e107)
                                        }
                                    };
                                    v107
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl DbConnection {
                #[allow(unused_unsafe, clippy::all)]
                pub fn execute(
                    &self,
                    statement: &str,
                    params: _rt::Vec<DbValue>,
                ) -> Result<u64, Error> {
                    unsafe {
                        let mut cleanup_list = _rt::Vec::new();
                        #[repr(align(8))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 24]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 24],
                        );
                        let vec0 = statement;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let vec87 = &params;
                        let len87 = vec87.len();
                        let layout87 = _rt::alloc::Layout::from_size_align_unchecked(
                            vec87.len() * 56,
                            8,
                        );
                        let result87 = if layout87.size() != 0 {
                            let ptr = _rt::alloc::alloc(layout87).cast::<u8>();
                            if ptr.is_null() {
                                _rt::alloc::handle_alloc_error(layout87);
                            }
                            ptr
                        } else {
                            ::core::ptr::null_mut()
                        };
                        for (i, e) in vec87.into_iter().enumerate() {
                            let base = result87.add(i * 56);
                            {
                                match e {
                                    DbValue::Character(e) => {
                                        *base.add(0).cast::<u8>() = (0i32) as u8;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                    }
                                    DbValue::Int2(e) => {
                                        *base.add(0).cast::<u8>() = (1i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::Int4(e) => {
                                        *base.add(0).cast::<u8>() = (2i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Int8(e) => {
                                        *base.add(0).cast::<u8>() = (3i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::Float4(e) => {
                                        *base.add(0).cast::<u8>() = (4i32) as u8;
                                        *base.add(8).cast::<f32>() = _rt::as_f32(e);
                                    }
                                    DbValue::Float8(e) => {
                                        *base.add(0).cast::<u8>() = (5i32) as u8;
                                        *base.add(8).cast::<f64>() = _rt::as_f64(e);
                                    }
                                    DbValue::Numeric(e) => {
                                        *base.add(0).cast::<u8>() = (6i32) as u8;
                                        let vec1 = e;
                                        let ptr1 = vec1.as_ptr().cast::<u8>();
                                        let len1 = vec1.len();
                                        *base.add(12).cast::<usize>() = len1;
                                        *base.add(8).cast::<*mut u8>() = ptr1.cast_mut();
                                    }
                                    DbValue::Boolean(e) => {
                                        *base.add(0).cast::<u8>() = (7i32) as u8;
                                        *base.add(8).cast::<u8>() = (match e {
                                            true => 1,
                                            false => 0,
                                        }) as u8;
                                    }
                                    DbValue::Text(e) => {
                                        *base.add(0).cast::<u8>() = (8i32) as u8;
                                        let vec2 = e;
                                        let ptr2 = vec2.as_ptr().cast::<u8>();
                                        let len2 = vec2.len();
                                        *base.add(12).cast::<usize>() = len2;
                                        *base.add(8).cast::<*mut u8>() = ptr2.cast_mut();
                                    }
                                    DbValue::Varchar(e) => {
                                        *base.add(0).cast::<u8>() = (9i32) as u8;
                                        let vec3 = e;
                                        let ptr3 = vec3.as_ptr().cast::<u8>();
                                        let len3 = vec3.len();
                                        *base.add(12).cast::<usize>() = len3;
                                        *base.add(8).cast::<*mut u8>() = ptr3.cast_mut();
                                    }
                                    DbValue::Bpchar(e) => {
                                        *base.add(0).cast::<u8>() = (10i32) as u8;
                                        let vec4 = e;
                                        let ptr4 = vec4.as_ptr().cast::<u8>();
                                        let len4 = vec4.len();
                                        *base.add(12).cast::<usize>() = len4;
                                        *base.add(8).cast::<*mut u8>() = ptr4.cast_mut();
                                    }
                                    DbValue::Timestamp(e) => {
                                        *base.add(0).cast::<u8>() = (11i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date5,
                                            time: time5,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year6,
                                            month: month6,
                                            day: day6,
                                        } = date5;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year6);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month6)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day6)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour7,
                                            minute: minute7,
                                            second: second7,
                                            nanosecond: nanosecond7,
                                        } = time5;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour7)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute7)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second7)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond7);
                                    }
                                    DbValue::Timestamptz(e) => {
                                        *base.add(0).cast::<u8>() = (12i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamptz {
                                            timestamp: timestamp8,
                                            offset: offset8,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date9,
                                            time: time9,
                                        } = timestamp8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year10,
                                            month: month10,
                                            day: day10,
                                        } = date9;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year10);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month10)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day10)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour11,
                                            minute: minute11,
                                            second: second11,
                                            nanosecond: nanosecond11,
                                        } = time9;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour11)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute11)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second11)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond11);
                                        *base.add(24).cast::<i32>() = _rt::as_i32(offset8);
                                    }
                                    DbValue::Date(e) => {
                                        *base.add(0).cast::<u8>() = (13i32) as u8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year12,
                                            month: month12,
                                            day: day12,
                                        } = e;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year12);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month12)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day12)) as u8;
                                    }
                                    DbValue::Time(e) => {
                                        *base.add(0).cast::<u8>() = (14i32) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour13,
                                            minute: minute13,
                                            second: second13,
                                            nanosecond: nanosecond13,
                                        } = e;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(hour13)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(minute13)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(second13)) as u8;
                                        *base.add(12).cast::<i32>() = _rt::as_i32(nanosecond13);
                                    }
                                    DbValue::Timetz(e) => {
                                        *base.add(0).cast::<u8>() = (15i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timetz {
                                            time: time14,
                                            offset: offset14,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour15,
                                            minute: minute15,
                                            second: second15,
                                            nanosecond: nanosecond15,
                                        } = time14;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(hour15)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(minute15)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(second15)) as u8;
                                        *base.add(12).cast::<i32>() = _rt::as_i32(nanosecond15);
                                        *base.add(16).cast::<i32>() = _rt::as_i32(offset14);
                                    }
                                    DbValue::Interval(e) => {
                                        *base.add(0).cast::<u8>() = (16i32) as u8;
                                        let Interval {
                                            months: months16,
                                            days: days16,
                                            microseconds: microseconds16,
                                        } = e;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(months16);
                                        *base.add(12).cast::<i32>() = _rt::as_i32(days16);
                                        *base.add(16).cast::<i64>() = _rt::as_i64(microseconds16);
                                    }
                                    DbValue::Bytea(e) => {
                                        *base.add(0).cast::<u8>() = (17i32) as u8;
                                        let vec17 = e;
                                        let ptr17 = vec17.as_ptr().cast::<u8>();
                                        let len17 = vec17.len();
                                        *base.add(12).cast::<usize>() = len17;
                                        *base.add(8).cast::<*mut u8>() = ptr17.cast_mut();
                                    }
                                    DbValue::Json(e) => {
                                        *base.add(0).cast::<u8>() = (18i32) as u8;
                                        let vec18 = e;
                                        let ptr18 = vec18.as_ptr().cast::<u8>();
                                        let len18 = vec18.len();
                                        *base.add(12).cast::<usize>() = len18;
                                        *base.add(8).cast::<*mut u8>() = ptr18.cast_mut();
                                    }
                                    DbValue::Jsonb(e) => {
                                        *base.add(0).cast::<u8>() = (19i32) as u8;
                                        let vec19 = e;
                                        let ptr19 = vec19.as_ptr().cast::<u8>();
                                        let len19 = vec19.len();
                                        *base.add(12).cast::<usize>() = len19;
                                        *base.add(8).cast::<*mut u8>() = ptr19.cast_mut();
                                    }
                                    DbValue::Jsonpath(e) => {
                                        *base.add(0).cast::<u8>() = (20i32) as u8;
                                        let vec20 = e;
                                        let ptr20 = vec20.as_ptr().cast::<u8>();
                                        let len20 = vec20.len();
                                        *base.add(12).cast::<usize>() = len20;
                                        *base.add(8).cast::<*mut u8>() = ptr20.cast_mut();
                                    }
                                    DbValue::Xml(e) => {
                                        *base.add(0).cast::<u8>() = (21i32) as u8;
                                        let vec21 = e;
                                        let ptr21 = vec21.as_ptr().cast::<u8>();
                                        let len21 = vec21.len();
                                        *base.add(12).cast::<usize>() = len21;
                                        *base.add(8).cast::<*mut u8>() = ptr21.cast_mut();
                                    }
                                    DbValue::Uuid(e) => {
                                        *base.add(0).cast::<u8>() = (22i32) as u8;
                                        let super::super::super::golem::rdbms::types::Uuid {
                                            high_bits: high_bits22,
                                            low_bits: low_bits22,
                                        } = e;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(high_bits22);
                                        *base.add(16).cast::<i64>() = _rt::as_i64(low_bits22);
                                    }
                                    DbValue::Inet(e) => {
                                        *base.add(0).cast::<u8>() = (23i32) as u8;
                                        use super::super::super::golem::rdbms::types::IpAddress as V25;
                                        match e {
                                            V25::Ipv4(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let (t23_0, t23_1, t23_2, t23_3) = e;
                                                *base.add(10).cast::<u8>() = (_rt::as_i32(t23_0)) as u8;
                                                *base.add(11).cast::<u8>() = (_rt::as_i32(t23_1)) as u8;
                                                *base.add(12).cast::<u8>() = (_rt::as_i32(t23_2)) as u8;
                                                *base.add(13).cast::<u8>() = (_rt::as_i32(t23_3)) as u8;
                                            }
                                            V25::Ipv6(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let (
                                                    t24_0,
                                                    t24_1,
                                                    t24_2,
                                                    t24_3,
                                                    t24_4,
                                                    t24_5,
                                                    t24_6,
                                                    t24_7,
                                                ) = e;
                                                *base.add(10).cast::<u16>() = (_rt::as_i32(t24_0)) as u16;
                                                *base.add(12).cast::<u16>() = (_rt::as_i32(t24_1)) as u16;
                                                *base.add(14).cast::<u16>() = (_rt::as_i32(t24_2)) as u16;
                                                *base.add(16).cast::<u16>() = (_rt::as_i32(t24_3)) as u16;
                                                *base.add(18).cast::<u16>() = (_rt::as_i32(t24_4)) as u16;
                                                *base.add(20).cast::<u16>() = (_rt::as_i32(t24_5)) as u16;
                                                *base.add(22).cast::<u16>() = (_rt::as_i32(t24_6)) as u16;
                                                *base.add(24).cast::<u16>() = (_rt::as_i32(t24_7)) as u16;
                                            }
                                        }
                                    }
                                    DbValue::Cidr(e) => {
                                        *base.add(0).cast::<u8>() = (24i32) as u8;
                                        use super::super::super::golem::rdbms::types::IpAddress as V28;
                                        match e {
                                            V28::Ipv4(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let (t26_0, t26_1, t26_2, t26_3) = e;
                                                *base.add(10).cast::<u8>() = (_rt::as_i32(t26_0)) as u8;
                                                *base.add(11).cast::<u8>() = (_rt::as_i32(t26_1)) as u8;
                                                *base.add(12).cast::<u8>() = (_rt::as_i32(t26_2)) as u8;
                                                *base.add(13).cast::<u8>() = (_rt::as_i32(t26_3)) as u8;
                                            }
                                            V28::Ipv6(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let (
                                                    t27_0,
                                                    t27_1,
                                                    t27_2,
                                                    t27_3,
                                                    t27_4,
                                                    t27_5,
                                                    t27_6,
                                                    t27_7,
                                                ) = e;
                                                *base.add(10).cast::<u16>() = (_rt::as_i32(t27_0)) as u16;
                                                *base.add(12).cast::<u16>() = (_rt::as_i32(t27_1)) as u16;
                                                *base.add(14).cast::<u16>() = (_rt::as_i32(t27_2)) as u16;
                                                *base.add(16).cast::<u16>() = (_rt::as_i32(t27_3)) as u16;
                                                *base.add(18).cast::<u16>() = (_rt::as_i32(t27_4)) as u16;
                                                *base.add(20).cast::<u16>() = (_rt::as_i32(t27_5)) as u16;
                                                *base.add(22).cast::<u16>() = (_rt::as_i32(t27_6)) as u16;
                                                *base.add(24).cast::<u16>() = (_rt::as_i32(t27_7)) as u16;
                                            }
                                        }
                                    }
                                    DbValue::Macaddr(e) => {
                                        *base.add(0).cast::<u8>() = (25i32) as u8;
                                        let super::super::super::golem::rdbms::types::MacAddress {
                                            octets: octets29,
                                        } = e;
                                        let (t30_0, t30_1, t30_2, t30_3, t30_4, t30_5) = octets29;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(t30_0)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(t30_1)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(t30_2)) as u8;
                                        *base.add(11).cast::<u8>() = (_rt::as_i32(t30_3)) as u8;
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(t30_4)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(t30_5)) as u8;
                                    }
                                    DbValue::Bit(e) => {
                                        *base.add(0).cast::<u8>() = (26i32) as u8;
                                        let vec31 = e;
                                        let len31 = vec31.len();
                                        let layout31 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec31.len() * 1,
                                            1,
                                        );
                                        let result31 = if layout31.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout31).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout31);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec31.into_iter().enumerate() {
                                            let base = result31.add(i * 1);
                                            {
                                                *base.add(0).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len31;
                                        *base.add(8).cast::<*mut u8>() = result31;
                                        cleanup_list.extend_from_slice(&[(result31, layout31)]);
                                    }
                                    DbValue::Varbit(e) => {
                                        *base.add(0).cast::<u8>() = (27i32) as u8;
                                        let vec32 = e;
                                        let len32 = vec32.len();
                                        let layout32 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec32.len() * 1,
                                            1,
                                        );
                                        let result32 = if layout32.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout32).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout32);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec32.into_iter().enumerate() {
                                            let base = result32.add(i * 1);
                                            {
                                                *base.add(0).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len32;
                                        *base.add(8).cast::<*mut u8>() = result32;
                                        cleanup_list.extend_from_slice(&[(result32, layout32)]);
                                    }
                                    DbValue::Int4range(e) => {
                                        *base.add(0).cast::<u8>() = (28i32) as u8;
                                        let Int4range { start: start33, end: end33 } = e;
                                        match start33 {
                                            Int4bound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end33 {
                                            Int4bound::Included(e) => {
                                                *base.add(16).cast::<u8>() = (0i32) as u8;
                                                *base.add(20).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Excluded(e) => {
                                                *base.add(16).cast::<u8>() = (1i32) as u8;
                                                *base.add(20).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Unbounded => {
                                                *base.add(16).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Int8range(e) => {
                                        *base.add(0).cast::<u8>() = (29i32) as u8;
                                        let Int8range { start: start34, end: end34 } = e;
                                        match start34 {
                                            Int8bound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                *base.add(16).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                *base.add(16).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end34 {
                                            Int8bound::Included(e) => {
                                                *base.add(24).cast::<u8>() = (0i32) as u8;
                                                *base.add(32).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Excluded(e) => {
                                                *base.add(24).cast::<u8>() = (1i32) as u8;
                                                *base.add(32).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Unbounded => {
                                                *base.add(24).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Numrange(e) => {
                                        *base.add(0).cast::<u8>() = (30i32) as u8;
                                        let Numrange { start: start35, end: end35 } = e;
                                        match start35 {
                                            Numbound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let vec36 = e;
                                                let ptr36 = vec36.as_ptr().cast::<u8>();
                                                let len36 = vec36.len();
                                                *base.add(16).cast::<usize>() = len36;
                                                *base.add(12).cast::<*mut u8>() = ptr36.cast_mut();
                                            }
                                            Numbound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let vec37 = e;
                                                let ptr37 = vec37.as_ptr().cast::<u8>();
                                                let len37 = vec37.len();
                                                *base.add(16).cast::<usize>() = len37;
                                                *base.add(12).cast::<*mut u8>() = ptr37.cast_mut();
                                            }
                                            Numbound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end35 {
                                            Numbound::Included(e) => {
                                                *base.add(20).cast::<u8>() = (0i32) as u8;
                                                let vec38 = e;
                                                let ptr38 = vec38.as_ptr().cast::<u8>();
                                                let len38 = vec38.len();
                                                *base.add(28).cast::<usize>() = len38;
                                                *base.add(24).cast::<*mut u8>() = ptr38.cast_mut();
                                            }
                                            Numbound::Excluded(e) => {
                                                *base.add(20).cast::<u8>() = (1i32) as u8;
                                                let vec39 = e;
                                                let ptr39 = vec39.as_ptr().cast::<u8>();
                                                let len39 = vec39.len();
                                                *base.add(28).cast::<usize>() = len39;
                                                *base.add(24).cast::<*mut u8>() = ptr39.cast_mut();
                                            }
                                            Numbound::Unbounded => {
                                                *base.add(20).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Tsrange(e) => {
                                        *base.add(0).cast::<u8>() = (31i32) as u8;
                                        let Tsrange { start: start40, end: end40 } = e;
                                        match start40 {
                                            Tsbound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date41,
                                                    time: time41,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year42,
                                                    month: month42,
                                                    day: day42,
                                                } = date41;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year42);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month42)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day42)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour43,
                                                    minute: minute43,
                                                    second: second43,
                                                    nanosecond: nanosecond43,
                                                } = time41;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour43)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute43)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second43)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond43);
                                            }
                                            Tsbound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date44,
                                                    time: time44,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year45,
                                                    month: month45,
                                                    day: day45,
                                                } = date44;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year45);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month45)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day45)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour46,
                                                    minute: minute46,
                                                    second: second46,
                                                    nanosecond: nanosecond46,
                                                } = time44;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour46)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute46)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second46)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond46);
                                            }
                                            Tsbound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end40 {
                                            Tsbound::Included(e) => {
                                                *base.add(28).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date47,
                                                    time: time47,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year48,
                                                    month: month48,
                                                    day: day48,
                                                } = date47;
                                                *base.add(32).cast::<i32>() = _rt::as_i32(year48);
                                                *base.add(36).cast::<u8>() = (_rt::as_i32(month48)) as u8;
                                                *base.add(37).cast::<u8>() = (_rt::as_i32(day48)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour49,
                                                    minute: minute49,
                                                    second: second49,
                                                    nanosecond: nanosecond49,
                                                } = time47;
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(hour49)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(minute49)) as u8;
                                                *base.add(42).cast::<u8>() = (_rt::as_i32(second49)) as u8;
                                                *base.add(44).cast::<i32>() = _rt::as_i32(nanosecond49);
                                            }
                                            Tsbound::Excluded(e) => {
                                                *base.add(28).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date50,
                                                    time: time50,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year51,
                                                    month: month51,
                                                    day: day51,
                                                } = date50;
                                                *base.add(32).cast::<i32>() = _rt::as_i32(year51);
                                                *base.add(36).cast::<u8>() = (_rt::as_i32(month51)) as u8;
                                                *base.add(37).cast::<u8>() = (_rt::as_i32(day51)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour52,
                                                    minute: minute52,
                                                    second: second52,
                                                    nanosecond: nanosecond52,
                                                } = time50;
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(hour52)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(minute52)) as u8;
                                                *base.add(42).cast::<u8>() = (_rt::as_i32(second52)) as u8;
                                                *base.add(44).cast::<i32>() = _rt::as_i32(nanosecond52);
                                            }
                                            Tsbound::Unbounded => {
                                                *base.add(28).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Tstzrange(e) => {
                                        *base.add(0).cast::<u8>() = (32i32) as u8;
                                        let Tstzrange { start: start53, end: end53 } = e;
                                        match start53 {
                                            Tstzbound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp54,
                                                    offset: offset54,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date55,
                                                    time: time55,
                                                } = timestamp54;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year56,
                                                    month: month56,
                                                    day: day56,
                                                } = date55;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year56);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month56)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day56)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour57,
                                                    minute: minute57,
                                                    second: second57,
                                                    nanosecond: nanosecond57,
                                                } = time55;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour57)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute57)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second57)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond57);
                                                *base.add(28).cast::<i32>() = _rt::as_i32(offset54);
                                            }
                                            Tstzbound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp58,
                                                    offset: offset58,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date59,
                                                    time: time59,
                                                } = timestamp58;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year60,
                                                    month: month60,
                                                    day: day60,
                                                } = date59;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year60);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month60)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day60)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour61,
                                                    minute: minute61,
                                                    second: second61,
                                                    nanosecond: nanosecond61,
                                                } = time59;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour61)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute61)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second61)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond61);
                                                *base.add(28).cast::<i32>() = _rt::as_i32(offset58);
                                            }
                                            Tstzbound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end53 {
                                            Tstzbound::Included(e) => {
                                                *base.add(32).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp62,
                                                    offset: offset62,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date63,
                                                    time: time63,
                                                } = timestamp62;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year64,
                                                    month: month64,
                                                    day: day64,
                                                } = date63;
                                                *base.add(36).cast::<i32>() = _rt::as_i32(year64);
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(month64)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(day64)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour65,
                                                    minute: minute65,
                                                    second: second65,
                                                    nanosecond: nanosecond65,
                                                } = time63;
                                                *base.add(44).cast::<u8>() = (_rt::as_i32(hour65)) as u8;
                                                *base.add(45).cast::<u8>() = (_rt::as_i32(minute65)) as u8;
                                                *base.add(46).cast::<u8>() = (_rt::as_i32(second65)) as u8;
                                                *base.add(48).cast::<i32>() = _rt::as_i32(nanosecond65);
                                                *base.add(52).cast::<i32>() = _rt::as_i32(offset62);
                                            }
                                            Tstzbound::Excluded(e) => {
                                                *base.add(32).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp66,
                                                    offset: offset66,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date67,
                                                    time: time67,
                                                } = timestamp66;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year68,
                                                    month: month68,
                                                    day: day68,
                                                } = date67;
                                                *base.add(36).cast::<i32>() = _rt::as_i32(year68);
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(month68)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(day68)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour69,
                                                    minute: minute69,
                                                    second: second69,
                                                    nanosecond: nanosecond69,
                                                } = time67;
                                                *base.add(44).cast::<u8>() = (_rt::as_i32(hour69)) as u8;
                                                *base.add(45).cast::<u8>() = (_rt::as_i32(minute69)) as u8;
                                                *base.add(46).cast::<u8>() = (_rt::as_i32(second69)) as u8;
                                                *base.add(48).cast::<i32>() = _rt::as_i32(nanosecond69);
                                                *base.add(52).cast::<i32>() = _rt::as_i32(offset66);
                                            }
                                            Tstzbound::Unbounded => {
                                                *base.add(32).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Daterange(e) => {
                                        *base.add(0).cast::<u8>() = (33i32) as u8;
                                        let Daterange { start: start70, end: end70 } = e;
                                        match start70 {
                                            Datebound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year71,
                                                    month: month71,
                                                    day: day71,
                                                } = e;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year71);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month71)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day71)) as u8;
                                            }
                                            Datebound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year72,
                                                    month: month72,
                                                    day: day72,
                                                } = e;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year72);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month72)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day72)) as u8;
                                            }
                                            Datebound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end70 {
                                            Datebound::Included(e) => {
                                                *base.add(20).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year73,
                                                    month: month73,
                                                    day: day73,
                                                } = e;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(year73);
                                                *base.add(28).cast::<u8>() = (_rt::as_i32(month73)) as u8;
                                                *base.add(29).cast::<u8>() = (_rt::as_i32(day73)) as u8;
                                            }
                                            Datebound::Excluded(e) => {
                                                *base.add(20).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year74,
                                                    month: month74,
                                                    day: day74,
                                                } = e;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(year74);
                                                *base.add(28).cast::<u8>() = (_rt::as_i32(month74)) as u8;
                                                *base.add(29).cast::<u8>() = (_rt::as_i32(day74)) as u8;
                                            }
                                            Datebound::Unbounded => {
                                                *base.add(20).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Money(e) => {
                                        *base.add(0).cast::<u8>() = (34i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::Oid(e) => {
                                        *base.add(0).cast::<u8>() = (35i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Enumeration(e) => {
                                        *base.add(0).cast::<u8>() = (36i32) as u8;
                                        let Enumeration { name: name75, value: value75 } = e;
                                        let vec76 = name75;
                                        let ptr76 = vec76.as_ptr().cast::<u8>();
                                        let len76 = vec76.len();
                                        *base.add(12).cast::<usize>() = len76;
                                        *base.add(8).cast::<*mut u8>() = ptr76.cast_mut();
                                        let vec77 = value75;
                                        let ptr77 = vec77.as_ptr().cast::<u8>();
                                        let len77 = vec77.len();
                                        *base.add(20).cast::<usize>() = len77;
                                        *base.add(16).cast::<*mut u8>() = ptr77.cast_mut();
                                    }
                                    DbValue::Composite(e) => {
                                        *base.add(0).cast::<u8>() = (37i32) as u8;
                                        let Composite { name: name78, values: values78 } = e;
                                        let vec79 = name78;
                                        let ptr79 = vec79.as_ptr().cast::<u8>();
                                        let len79 = vec79.len();
                                        *base.add(12).cast::<usize>() = len79;
                                        *base.add(8).cast::<*mut u8>() = ptr79.cast_mut();
                                        let vec80 = values78;
                                        let len80 = vec80.len();
                                        let layout80 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec80.len() * 4,
                                            4,
                                        );
                                        let result80 = if layout80.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout80).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout80);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec80.into_iter().enumerate() {
                                            let base = result80.add(i * 4);
                                            {
                                                *base.add(0).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                        }
                                        *base.add(20).cast::<usize>() = len80;
                                        *base.add(16).cast::<*mut u8>() = result80;
                                        cleanup_list.extend_from_slice(&[(result80, layout80)]);
                                    }
                                    DbValue::Domain(e) => {
                                        *base.add(0).cast::<u8>() = (38i32) as u8;
                                        let Domain { name: name81, value: value81 } = e;
                                        let vec82 = name81;
                                        let ptr82 = vec82.as_ptr().cast::<u8>();
                                        let len82 = vec82.len();
                                        *base.add(12).cast::<usize>() = len82;
                                        *base.add(8).cast::<*mut u8>() = ptr82.cast_mut();
                                        *base.add(16).cast::<i32>() = (value81).take_handle()
                                            as i32;
                                    }
                                    DbValue::Array(e) => {
                                        *base.add(0).cast::<u8>() = (39i32) as u8;
                                        let vec83 = e;
                                        let len83 = vec83.len();
                                        let layout83 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec83.len() * 4,
                                            4,
                                        );
                                        let result83 = if layout83.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout83).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout83);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec83.into_iter().enumerate() {
                                            let base = result83.add(i * 4);
                                            {
                                                *base.add(0).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len83;
                                        *base.add(8).cast::<*mut u8>() = result83;
                                        cleanup_list.extend_from_slice(&[(result83, layout83)]);
                                    }
                                    DbValue::Range(e) => {
                                        *base.add(0).cast::<u8>() = (40i32) as u8;
                                        let Range { name: name84, value: value84 } = e;
                                        let vec85 = name84;
                                        let ptr85 = vec85.as_ptr().cast::<u8>();
                                        let len85 = vec85.len();
                                        *base.add(12).cast::<usize>() = len85;
                                        *base.add(8).cast::<*mut u8>() = ptr85.cast_mut();
                                        let ValuesRange { start: start86, end: end86 } = value84;
                                        match start86 {
                                            ValueBound::Included(e) => {
                                                *base.add(16).cast::<u8>() = (0i32) as u8;
                                                *base.add(20).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Excluded(e) => {
                                                *base.add(16).cast::<u8>() = (1i32) as u8;
                                                *base.add(20).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Unbounded => {
                                                *base.add(16).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end86 {
                                            ValueBound::Included(e) => {
                                                *base.add(24).cast::<u8>() = (0i32) as u8;
                                                *base.add(28).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Excluded(e) => {
                                                *base.add(24).cast::<u8>() = (1i32) as u8;
                                                *base.add(28).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Unbounded => {
                                                *base.add(24).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Null => {
                                        *base.add(0).cast::<u8>() = (41i32) as u8;
                                    }
                                }
                            }
                        }
                        let ptr88 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rdbms/postgres@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-connection.execute"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            result87,
                            len87,
                            ptr88,
                        );
                        let l89 = i32::from(*ptr88.add(0).cast::<u8>());
                        if layout87.size() != 0 {
                            _rt::alloc::dealloc(result87.cast(), layout87);
                        }
                        for (ptr, layout) in cleanup_list {
                            if layout.size() != 0 {
                                _rt::alloc::dealloc(ptr.cast(), layout);
                            }
                        }
                        match l89 {
                            0 => {
                                let e = {
                                    let l90 = *ptr88.add(8).cast::<i64>();
                                    l90 as u64
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l91 = i32::from(*ptr88.add(8).cast::<u8>());
                                    let v107 = match l91 {
                                        0 => {
                                            let e107 = {
                                                let l92 = *ptr88.add(12).cast::<*mut u8>();
                                                let l93 = *ptr88.add(16).cast::<usize>();
                                                let len94 = l93;
                                                let bytes94 = _rt::Vec::from_raw_parts(
                                                    l92.cast(),
                                                    len94,
                                                    len94,
                                                );
                                                _rt::string_lift(bytes94)
                                            };
                                            Error::ConnectionFailure(e107)
                                        }
                                        1 => {
                                            let e107 = {
                                                let l95 = *ptr88.add(12).cast::<*mut u8>();
                                                let l96 = *ptr88.add(16).cast::<usize>();
                                                let len97 = l96;
                                                let bytes97 = _rt::Vec::from_raw_parts(
                                                    l95.cast(),
                                                    len97,
                                                    len97,
                                                );
                                                _rt::string_lift(bytes97)
                                            };
                                            Error::QueryParameterFailure(e107)
                                        }
                                        2 => {
                                            let e107 = {
                                                let l98 = *ptr88.add(12).cast::<*mut u8>();
                                                let l99 = *ptr88.add(16).cast::<usize>();
                                                let len100 = l99;
                                                let bytes100 = _rt::Vec::from_raw_parts(
                                                    l98.cast(),
                                                    len100,
                                                    len100,
                                                );
                                                _rt::string_lift(bytes100)
                                            };
                                            Error::QueryExecutionFailure(e107)
                                        }
                                        3 => {
                                            let e107 = {
                                                let l101 = *ptr88.add(12).cast::<*mut u8>();
                                                let l102 = *ptr88.add(16).cast::<usize>();
                                                let len103 = l102;
                                                let bytes103 = _rt::Vec::from_raw_parts(
                                                    l101.cast(),
                                                    len103,
                                                    len103,
                                                );
                                                _rt::string_lift(bytes103)
                                            };
                                            Error::QueryResponseFailure(e107)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 4, "invalid enum discriminant");
                                            let e107 = {
                                                let l104 = *ptr88.add(12).cast::<*mut u8>();
                                                let l105 = *ptr88.add(16).cast::<usize>();
                                                let len106 = l105;
                                                let bytes106 = _rt::Vec::from_raw_parts(
                                                    l104.cast(),
                                                    len106,
                                                    len106,
                                                );
                                                _rt::string_lift(bytes106)
                                            };
                                            Error::Other(e107)
                                        }
                                    };
                                    v107
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl DbConnection {
                #[allow(unused_unsafe, clippy::all)]
                pub fn begin_transaction(&self) -> Result<DbTransaction, Error> {
                    unsafe {
                        #[repr(align(4))]
                        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 = "golem:rdbms/postgres@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-connection.begin-transaction"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<i32>();
                                    DbTransaction::from_handle(l2 as u32)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = i32::from(*ptr0.add(4).cast::<u8>());
                                    let v19 = match l3 {
                                        0 => {
                                            let e19 = {
                                                let l4 = *ptr0.add(8).cast::<*mut u8>();
                                                let l5 = *ptr0.add(12).cast::<usize>();
                                                let len6 = l5;
                                                let bytes6 = _rt::Vec::from_raw_parts(
                                                    l4.cast(),
                                                    len6,
                                                    len6,
                                                );
                                                _rt::string_lift(bytes6)
                                            };
                                            Error::ConnectionFailure(e19)
                                        }
                                        1 => {
                                            let e19 = {
                                                let l7 = *ptr0.add(8).cast::<*mut u8>();
                                                let l8 = *ptr0.add(12).cast::<usize>();
                                                let len9 = l8;
                                                let bytes9 = _rt::Vec::from_raw_parts(
                                                    l7.cast(),
                                                    len9,
                                                    len9,
                                                );
                                                _rt::string_lift(bytes9)
                                            };
                                            Error::QueryParameterFailure(e19)
                                        }
                                        2 => {
                                            let e19 = {
                                                let l10 = *ptr0.add(8).cast::<*mut u8>();
                                                let l11 = *ptr0.add(12).cast::<usize>();
                                                let len12 = l11;
                                                let bytes12 = _rt::Vec::from_raw_parts(
                                                    l10.cast(),
                                                    len12,
                                                    len12,
                                                );
                                                _rt::string_lift(bytes12)
                                            };
                                            Error::QueryExecutionFailure(e19)
                                        }
                                        3 => {
                                            let e19 = {
                                                let l13 = *ptr0.add(8).cast::<*mut u8>();
                                                let l14 = *ptr0.add(12).cast::<usize>();
                                                let len15 = l14;
                                                let bytes15 = _rt::Vec::from_raw_parts(
                                                    l13.cast(),
                                                    len15,
                                                    len15,
                                                );
                                                _rt::string_lift(bytes15)
                                            };
                                            Error::QueryResponseFailure(e19)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 4, "invalid enum discriminant");
                                            let e19 = {
                                                let l16 = *ptr0.add(8).cast::<*mut u8>();
                                                let l17 = *ptr0.add(12).cast::<usize>();
                                                let len18 = l17;
                                                let bytes18 = _rt::Vec::from_raw_parts(
                                                    l16.cast(),
                                                    len18,
                                                    len18,
                                                );
                                                _rt::string_lift(bytes18)
                                            };
                                            Error::Other(e19)
                                        }
                                    };
                                    v19
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl DbTransaction {
                #[allow(unused_unsafe, clippy::all)]
                pub fn query(
                    &self,
                    statement: &str,
                    params: _rt::Vec<DbValue>,
                ) -> Result<DbResult, Error> {
                    unsafe {
                        let mut cleanup_list = _rt::Vec::new();
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 20]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 20],
                        );
                        let vec0 = statement;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let vec87 = &params;
                        let len87 = vec87.len();
                        let layout87 = _rt::alloc::Layout::from_size_align_unchecked(
                            vec87.len() * 56,
                            8,
                        );
                        let result87 = if layout87.size() != 0 {
                            let ptr = _rt::alloc::alloc(layout87).cast::<u8>();
                            if ptr.is_null() {
                                _rt::alloc::handle_alloc_error(layout87);
                            }
                            ptr
                        } else {
                            ::core::ptr::null_mut()
                        };
                        for (i, e) in vec87.into_iter().enumerate() {
                            let base = result87.add(i * 56);
                            {
                                match e {
                                    DbValue::Character(e) => {
                                        *base.add(0).cast::<u8>() = (0i32) as u8;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                    }
                                    DbValue::Int2(e) => {
                                        *base.add(0).cast::<u8>() = (1i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::Int4(e) => {
                                        *base.add(0).cast::<u8>() = (2i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Int8(e) => {
                                        *base.add(0).cast::<u8>() = (3i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::Float4(e) => {
                                        *base.add(0).cast::<u8>() = (4i32) as u8;
                                        *base.add(8).cast::<f32>() = _rt::as_f32(e);
                                    }
                                    DbValue::Float8(e) => {
                                        *base.add(0).cast::<u8>() = (5i32) as u8;
                                        *base.add(8).cast::<f64>() = _rt::as_f64(e);
                                    }
                                    DbValue::Numeric(e) => {
                                        *base.add(0).cast::<u8>() = (6i32) as u8;
                                        let vec1 = e;
                                        let ptr1 = vec1.as_ptr().cast::<u8>();
                                        let len1 = vec1.len();
                                        *base.add(12).cast::<usize>() = len1;
                                        *base.add(8).cast::<*mut u8>() = ptr1.cast_mut();
                                    }
                                    DbValue::Boolean(e) => {
                                        *base.add(0).cast::<u8>() = (7i32) as u8;
                                        *base.add(8).cast::<u8>() = (match e {
                                            true => 1,
                                            false => 0,
                                        }) as u8;
                                    }
                                    DbValue::Text(e) => {
                                        *base.add(0).cast::<u8>() = (8i32) as u8;
                                        let vec2 = e;
                                        let ptr2 = vec2.as_ptr().cast::<u8>();
                                        let len2 = vec2.len();
                                        *base.add(12).cast::<usize>() = len2;
                                        *base.add(8).cast::<*mut u8>() = ptr2.cast_mut();
                                    }
                                    DbValue::Varchar(e) => {
                                        *base.add(0).cast::<u8>() = (9i32) as u8;
                                        let vec3 = e;
                                        let ptr3 = vec3.as_ptr().cast::<u8>();
                                        let len3 = vec3.len();
                                        *base.add(12).cast::<usize>() = len3;
                                        *base.add(8).cast::<*mut u8>() = ptr3.cast_mut();
                                    }
                                    DbValue::Bpchar(e) => {
                                        *base.add(0).cast::<u8>() = (10i32) as u8;
                                        let vec4 = e;
                                        let ptr4 = vec4.as_ptr().cast::<u8>();
                                        let len4 = vec4.len();
                                        *base.add(12).cast::<usize>() = len4;
                                        *base.add(8).cast::<*mut u8>() = ptr4.cast_mut();
                                    }
                                    DbValue::Timestamp(e) => {
                                        *base.add(0).cast::<u8>() = (11i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date5,
                                            time: time5,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year6,
                                            month: month6,
                                            day: day6,
                                        } = date5;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year6);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month6)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day6)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour7,
                                            minute: minute7,
                                            second: second7,
                                            nanosecond: nanosecond7,
                                        } = time5;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour7)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute7)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second7)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond7);
                                    }
                                    DbValue::Timestamptz(e) => {
                                        *base.add(0).cast::<u8>() = (12i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamptz {
                                            timestamp: timestamp8,
                                            offset: offset8,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date9,
                                            time: time9,
                                        } = timestamp8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year10,
                                            month: month10,
                                            day: day10,
                                        } = date9;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year10);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month10)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day10)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour11,
                                            minute: minute11,
                                            second: second11,
                                            nanosecond: nanosecond11,
                                        } = time9;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour11)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute11)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second11)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond11);
                                        *base.add(24).cast::<i32>() = _rt::as_i32(offset8);
                                    }
                                    DbValue::Date(e) => {
                                        *base.add(0).cast::<u8>() = (13i32) as u8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year12,
                                            month: month12,
                                            day: day12,
                                        } = e;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year12);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month12)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day12)) as u8;
                                    }
                                    DbValue::Time(e) => {
                                        *base.add(0).cast::<u8>() = (14i32) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour13,
                                            minute: minute13,
                                            second: second13,
                                            nanosecond: nanosecond13,
                                        } = e;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(hour13)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(minute13)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(second13)) as u8;
                                        *base.add(12).cast::<i32>() = _rt::as_i32(nanosecond13);
                                    }
                                    DbValue::Timetz(e) => {
                                        *base.add(0).cast::<u8>() = (15i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timetz {
                                            time: time14,
                                            offset: offset14,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour15,
                                            minute: minute15,
                                            second: second15,
                                            nanosecond: nanosecond15,
                                        } = time14;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(hour15)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(minute15)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(second15)) as u8;
                                        *base.add(12).cast::<i32>() = _rt::as_i32(nanosecond15);
                                        *base.add(16).cast::<i32>() = _rt::as_i32(offset14);
                                    }
                                    DbValue::Interval(e) => {
                                        *base.add(0).cast::<u8>() = (16i32) as u8;
                                        let Interval {
                                            months: months16,
                                            days: days16,
                                            microseconds: microseconds16,
                                        } = e;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(months16);
                                        *base.add(12).cast::<i32>() = _rt::as_i32(days16);
                                        *base.add(16).cast::<i64>() = _rt::as_i64(microseconds16);
                                    }
                                    DbValue::Bytea(e) => {
                                        *base.add(0).cast::<u8>() = (17i32) as u8;
                                        let vec17 = e;
                                        let ptr17 = vec17.as_ptr().cast::<u8>();
                                        let len17 = vec17.len();
                                        *base.add(12).cast::<usize>() = len17;
                                        *base.add(8).cast::<*mut u8>() = ptr17.cast_mut();
                                    }
                                    DbValue::Json(e) => {
                                        *base.add(0).cast::<u8>() = (18i32) as u8;
                                        let vec18 = e;
                                        let ptr18 = vec18.as_ptr().cast::<u8>();
                                        let len18 = vec18.len();
                                        *base.add(12).cast::<usize>() = len18;
                                        *base.add(8).cast::<*mut u8>() = ptr18.cast_mut();
                                    }
                                    DbValue::Jsonb(e) => {
                                        *base.add(0).cast::<u8>() = (19i32) as u8;
                                        let vec19 = e;
                                        let ptr19 = vec19.as_ptr().cast::<u8>();
                                        let len19 = vec19.len();
                                        *base.add(12).cast::<usize>() = len19;
                                        *base.add(8).cast::<*mut u8>() = ptr19.cast_mut();
                                    }
                                    DbValue::Jsonpath(e) => {
                                        *base.add(0).cast::<u8>() = (20i32) as u8;
                                        let vec20 = e;
                                        let ptr20 = vec20.as_ptr().cast::<u8>();
                                        let len20 = vec20.len();
                                        *base.add(12).cast::<usize>() = len20;
                                        *base.add(8).cast::<*mut u8>() = ptr20.cast_mut();
                                    }
                                    DbValue::Xml(e) => {
                                        *base.add(0).cast::<u8>() = (21i32) as u8;
                                        let vec21 = e;
                                        let ptr21 = vec21.as_ptr().cast::<u8>();
                                        let len21 = vec21.len();
                                        *base.add(12).cast::<usize>() = len21;
                                        *base.add(8).cast::<*mut u8>() = ptr21.cast_mut();
                                    }
                                    DbValue::Uuid(e) => {
                                        *base.add(0).cast::<u8>() = (22i32) as u8;
                                        let super::super::super::golem::rdbms::types::Uuid {
                                            high_bits: high_bits22,
                                            low_bits: low_bits22,
                                        } = e;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(high_bits22);
                                        *base.add(16).cast::<i64>() = _rt::as_i64(low_bits22);
                                    }
                                    DbValue::Inet(e) => {
                                        *base.add(0).cast::<u8>() = (23i32) as u8;
                                        use super::super::super::golem::rdbms::types::IpAddress as V25;
                                        match e {
                                            V25::Ipv4(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let (t23_0, t23_1, t23_2, t23_3) = e;
                                                *base.add(10).cast::<u8>() = (_rt::as_i32(t23_0)) as u8;
                                                *base.add(11).cast::<u8>() = (_rt::as_i32(t23_1)) as u8;
                                                *base.add(12).cast::<u8>() = (_rt::as_i32(t23_2)) as u8;
                                                *base.add(13).cast::<u8>() = (_rt::as_i32(t23_3)) as u8;
                                            }
                                            V25::Ipv6(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let (
                                                    t24_0,
                                                    t24_1,
                                                    t24_2,
                                                    t24_3,
                                                    t24_4,
                                                    t24_5,
                                                    t24_6,
                                                    t24_7,
                                                ) = e;
                                                *base.add(10).cast::<u16>() = (_rt::as_i32(t24_0)) as u16;
                                                *base.add(12).cast::<u16>() = (_rt::as_i32(t24_1)) as u16;
                                                *base.add(14).cast::<u16>() = (_rt::as_i32(t24_2)) as u16;
                                                *base.add(16).cast::<u16>() = (_rt::as_i32(t24_3)) as u16;
                                                *base.add(18).cast::<u16>() = (_rt::as_i32(t24_4)) as u16;
                                                *base.add(20).cast::<u16>() = (_rt::as_i32(t24_5)) as u16;
                                                *base.add(22).cast::<u16>() = (_rt::as_i32(t24_6)) as u16;
                                                *base.add(24).cast::<u16>() = (_rt::as_i32(t24_7)) as u16;
                                            }
                                        }
                                    }
                                    DbValue::Cidr(e) => {
                                        *base.add(0).cast::<u8>() = (24i32) as u8;
                                        use super::super::super::golem::rdbms::types::IpAddress as V28;
                                        match e {
                                            V28::Ipv4(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let (t26_0, t26_1, t26_2, t26_3) = e;
                                                *base.add(10).cast::<u8>() = (_rt::as_i32(t26_0)) as u8;
                                                *base.add(11).cast::<u8>() = (_rt::as_i32(t26_1)) as u8;
                                                *base.add(12).cast::<u8>() = (_rt::as_i32(t26_2)) as u8;
                                                *base.add(13).cast::<u8>() = (_rt::as_i32(t26_3)) as u8;
                                            }
                                            V28::Ipv6(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let (
                                                    t27_0,
                                                    t27_1,
                                                    t27_2,
                                                    t27_3,
                                                    t27_4,
                                                    t27_5,
                                                    t27_6,
                                                    t27_7,
                                                ) = e;
                                                *base.add(10).cast::<u16>() = (_rt::as_i32(t27_0)) as u16;
                                                *base.add(12).cast::<u16>() = (_rt::as_i32(t27_1)) as u16;
                                                *base.add(14).cast::<u16>() = (_rt::as_i32(t27_2)) as u16;
                                                *base.add(16).cast::<u16>() = (_rt::as_i32(t27_3)) as u16;
                                                *base.add(18).cast::<u16>() = (_rt::as_i32(t27_4)) as u16;
                                                *base.add(20).cast::<u16>() = (_rt::as_i32(t27_5)) as u16;
                                                *base.add(22).cast::<u16>() = (_rt::as_i32(t27_6)) as u16;
                                                *base.add(24).cast::<u16>() = (_rt::as_i32(t27_7)) as u16;
                                            }
                                        }
                                    }
                                    DbValue::Macaddr(e) => {
                                        *base.add(0).cast::<u8>() = (25i32) as u8;
                                        let super::super::super::golem::rdbms::types::MacAddress {
                                            octets: octets29,
                                        } = e;
                                        let (t30_0, t30_1, t30_2, t30_3, t30_4, t30_5) = octets29;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(t30_0)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(t30_1)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(t30_2)) as u8;
                                        *base.add(11).cast::<u8>() = (_rt::as_i32(t30_3)) as u8;
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(t30_4)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(t30_5)) as u8;
                                    }
                                    DbValue::Bit(e) => {
                                        *base.add(0).cast::<u8>() = (26i32) as u8;
                                        let vec31 = e;
                                        let len31 = vec31.len();
                                        let layout31 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec31.len() * 1,
                                            1,
                                        );
                                        let result31 = if layout31.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout31).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout31);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec31.into_iter().enumerate() {
                                            let base = result31.add(i * 1);
                                            {
                                                *base.add(0).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len31;
                                        *base.add(8).cast::<*mut u8>() = result31;
                                        cleanup_list.extend_from_slice(&[(result31, layout31)]);
                                    }
                                    DbValue::Varbit(e) => {
                                        *base.add(0).cast::<u8>() = (27i32) as u8;
                                        let vec32 = e;
                                        let len32 = vec32.len();
                                        let layout32 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec32.len() * 1,
                                            1,
                                        );
                                        let result32 = if layout32.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout32).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout32);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec32.into_iter().enumerate() {
                                            let base = result32.add(i * 1);
                                            {
                                                *base.add(0).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len32;
                                        *base.add(8).cast::<*mut u8>() = result32;
                                        cleanup_list.extend_from_slice(&[(result32, layout32)]);
                                    }
                                    DbValue::Int4range(e) => {
                                        *base.add(0).cast::<u8>() = (28i32) as u8;
                                        let Int4range { start: start33, end: end33 } = e;
                                        match start33 {
                                            Int4bound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end33 {
                                            Int4bound::Included(e) => {
                                                *base.add(16).cast::<u8>() = (0i32) as u8;
                                                *base.add(20).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Excluded(e) => {
                                                *base.add(16).cast::<u8>() = (1i32) as u8;
                                                *base.add(20).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Unbounded => {
                                                *base.add(16).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Int8range(e) => {
                                        *base.add(0).cast::<u8>() = (29i32) as u8;
                                        let Int8range { start: start34, end: end34 } = e;
                                        match start34 {
                                            Int8bound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                *base.add(16).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                *base.add(16).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end34 {
                                            Int8bound::Included(e) => {
                                                *base.add(24).cast::<u8>() = (0i32) as u8;
                                                *base.add(32).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Excluded(e) => {
                                                *base.add(24).cast::<u8>() = (1i32) as u8;
                                                *base.add(32).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Unbounded => {
                                                *base.add(24).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Numrange(e) => {
                                        *base.add(0).cast::<u8>() = (30i32) as u8;
                                        let Numrange { start: start35, end: end35 } = e;
                                        match start35 {
                                            Numbound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let vec36 = e;
                                                let ptr36 = vec36.as_ptr().cast::<u8>();
                                                let len36 = vec36.len();
                                                *base.add(16).cast::<usize>() = len36;
                                                *base.add(12).cast::<*mut u8>() = ptr36.cast_mut();
                                            }
                                            Numbound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let vec37 = e;
                                                let ptr37 = vec37.as_ptr().cast::<u8>();
                                                let len37 = vec37.len();
                                                *base.add(16).cast::<usize>() = len37;
                                                *base.add(12).cast::<*mut u8>() = ptr37.cast_mut();
                                            }
                                            Numbound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end35 {
                                            Numbound::Included(e) => {
                                                *base.add(20).cast::<u8>() = (0i32) as u8;
                                                let vec38 = e;
                                                let ptr38 = vec38.as_ptr().cast::<u8>();
                                                let len38 = vec38.len();
                                                *base.add(28).cast::<usize>() = len38;
                                                *base.add(24).cast::<*mut u8>() = ptr38.cast_mut();
                                            }
                                            Numbound::Excluded(e) => {
                                                *base.add(20).cast::<u8>() = (1i32) as u8;
                                                let vec39 = e;
                                                let ptr39 = vec39.as_ptr().cast::<u8>();
                                                let len39 = vec39.len();
                                                *base.add(28).cast::<usize>() = len39;
                                                *base.add(24).cast::<*mut u8>() = ptr39.cast_mut();
                                            }
                                            Numbound::Unbounded => {
                                                *base.add(20).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Tsrange(e) => {
                                        *base.add(0).cast::<u8>() = (31i32) as u8;
                                        let Tsrange { start: start40, end: end40 } = e;
                                        match start40 {
                                            Tsbound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date41,
                                                    time: time41,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year42,
                                                    month: month42,
                                                    day: day42,
                                                } = date41;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year42);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month42)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day42)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour43,
                                                    minute: minute43,
                                                    second: second43,
                                                    nanosecond: nanosecond43,
                                                } = time41;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour43)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute43)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second43)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond43);
                                            }
                                            Tsbound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date44,
                                                    time: time44,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year45,
                                                    month: month45,
                                                    day: day45,
                                                } = date44;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year45);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month45)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day45)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour46,
                                                    minute: minute46,
                                                    second: second46,
                                                    nanosecond: nanosecond46,
                                                } = time44;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour46)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute46)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second46)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond46);
                                            }
                                            Tsbound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end40 {
                                            Tsbound::Included(e) => {
                                                *base.add(28).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date47,
                                                    time: time47,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year48,
                                                    month: month48,
                                                    day: day48,
                                                } = date47;
                                                *base.add(32).cast::<i32>() = _rt::as_i32(year48);
                                                *base.add(36).cast::<u8>() = (_rt::as_i32(month48)) as u8;
                                                *base.add(37).cast::<u8>() = (_rt::as_i32(day48)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour49,
                                                    minute: minute49,
                                                    second: second49,
                                                    nanosecond: nanosecond49,
                                                } = time47;
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(hour49)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(minute49)) as u8;
                                                *base.add(42).cast::<u8>() = (_rt::as_i32(second49)) as u8;
                                                *base.add(44).cast::<i32>() = _rt::as_i32(nanosecond49);
                                            }
                                            Tsbound::Excluded(e) => {
                                                *base.add(28).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date50,
                                                    time: time50,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year51,
                                                    month: month51,
                                                    day: day51,
                                                } = date50;
                                                *base.add(32).cast::<i32>() = _rt::as_i32(year51);
                                                *base.add(36).cast::<u8>() = (_rt::as_i32(month51)) as u8;
                                                *base.add(37).cast::<u8>() = (_rt::as_i32(day51)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour52,
                                                    minute: minute52,
                                                    second: second52,
                                                    nanosecond: nanosecond52,
                                                } = time50;
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(hour52)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(minute52)) as u8;
                                                *base.add(42).cast::<u8>() = (_rt::as_i32(second52)) as u8;
                                                *base.add(44).cast::<i32>() = _rt::as_i32(nanosecond52);
                                            }
                                            Tsbound::Unbounded => {
                                                *base.add(28).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Tstzrange(e) => {
                                        *base.add(0).cast::<u8>() = (32i32) as u8;
                                        let Tstzrange { start: start53, end: end53 } = e;
                                        match start53 {
                                            Tstzbound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp54,
                                                    offset: offset54,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date55,
                                                    time: time55,
                                                } = timestamp54;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year56,
                                                    month: month56,
                                                    day: day56,
                                                } = date55;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year56);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month56)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day56)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour57,
                                                    minute: minute57,
                                                    second: second57,
                                                    nanosecond: nanosecond57,
                                                } = time55;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour57)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute57)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second57)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond57);
                                                *base.add(28).cast::<i32>() = _rt::as_i32(offset54);
                                            }
                                            Tstzbound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp58,
                                                    offset: offset58,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date59,
                                                    time: time59,
                                                } = timestamp58;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year60,
                                                    month: month60,
                                                    day: day60,
                                                } = date59;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year60);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month60)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day60)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour61,
                                                    minute: minute61,
                                                    second: second61,
                                                    nanosecond: nanosecond61,
                                                } = time59;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour61)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute61)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second61)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond61);
                                                *base.add(28).cast::<i32>() = _rt::as_i32(offset58);
                                            }
                                            Tstzbound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end53 {
                                            Tstzbound::Included(e) => {
                                                *base.add(32).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp62,
                                                    offset: offset62,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date63,
                                                    time: time63,
                                                } = timestamp62;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year64,
                                                    month: month64,
                                                    day: day64,
                                                } = date63;
                                                *base.add(36).cast::<i32>() = _rt::as_i32(year64);
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(month64)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(day64)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour65,
                                                    minute: minute65,
                                                    second: second65,
                                                    nanosecond: nanosecond65,
                                                } = time63;
                                                *base.add(44).cast::<u8>() = (_rt::as_i32(hour65)) as u8;
                                                *base.add(45).cast::<u8>() = (_rt::as_i32(minute65)) as u8;
                                                *base.add(46).cast::<u8>() = (_rt::as_i32(second65)) as u8;
                                                *base.add(48).cast::<i32>() = _rt::as_i32(nanosecond65);
                                                *base.add(52).cast::<i32>() = _rt::as_i32(offset62);
                                            }
                                            Tstzbound::Excluded(e) => {
                                                *base.add(32).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp66,
                                                    offset: offset66,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date67,
                                                    time: time67,
                                                } = timestamp66;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year68,
                                                    month: month68,
                                                    day: day68,
                                                } = date67;
                                                *base.add(36).cast::<i32>() = _rt::as_i32(year68);
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(month68)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(day68)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour69,
                                                    minute: minute69,
                                                    second: second69,
                                                    nanosecond: nanosecond69,
                                                } = time67;
                                                *base.add(44).cast::<u8>() = (_rt::as_i32(hour69)) as u8;
                                                *base.add(45).cast::<u8>() = (_rt::as_i32(minute69)) as u8;
                                                *base.add(46).cast::<u8>() = (_rt::as_i32(second69)) as u8;
                                                *base.add(48).cast::<i32>() = _rt::as_i32(nanosecond69);
                                                *base.add(52).cast::<i32>() = _rt::as_i32(offset66);
                                            }
                                            Tstzbound::Unbounded => {
                                                *base.add(32).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Daterange(e) => {
                                        *base.add(0).cast::<u8>() = (33i32) as u8;
                                        let Daterange { start: start70, end: end70 } = e;
                                        match start70 {
                                            Datebound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year71,
                                                    month: month71,
                                                    day: day71,
                                                } = e;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year71);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month71)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day71)) as u8;
                                            }
                                            Datebound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year72,
                                                    month: month72,
                                                    day: day72,
                                                } = e;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year72);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month72)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day72)) as u8;
                                            }
                                            Datebound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end70 {
                                            Datebound::Included(e) => {
                                                *base.add(20).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year73,
                                                    month: month73,
                                                    day: day73,
                                                } = e;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(year73);
                                                *base.add(28).cast::<u8>() = (_rt::as_i32(month73)) as u8;
                                                *base.add(29).cast::<u8>() = (_rt::as_i32(day73)) as u8;
                                            }
                                            Datebound::Excluded(e) => {
                                                *base.add(20).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year74,
                                                    month: month74,
                                                    day: day74,
                                                } = e;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(year74);
                                                *base.add(28).cast::<u8>() = (_rt::as_i32(month74)) as u8;
                                                *base.add(29).cast::<u8>() = (_rt::as_i32(day74)) as u8;
                                            }
                                            Datebound::Unbounded => {
                                                *base.add(20).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Money(e) => {
                                        *base.add(0).cast::<u8>() = (34i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::Oid(e) => {
                                        *base.add(0).cast::<u8>() = (35i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Enumeration(e) => {
                                        *base.add(0).cast::<u8>() = (36i32) as u8;
                                        let Enumeration { name: name75, value: value75 } = e;
                                        let vec76 = name75;
                                        let ptr76 = vec76.as_ptr().cast::<u8>();
                                        let len76 = vec76.len();
                                        *base.add(12).cast::<usize>() = len76;
                                        *base.add(8).cast::<*mut u8>() = ptr76.cast_mut();
                                        let vec77 = value75;
                                        let ptr77 = vec77.as_ptr().cast::<u8>();
                                        let len77 = vec77.len();
                                        *base.add(20).cast::<usize>() = len77;
                                        *base.add(16).cast::<*mut u8>() = ptr77.cast_mut();
                                    }
                                    DbValue::Composite(e) => {
                                        *base.add(0).cast::<u8>() = (37i32) as u8;
                                        let Composite { name: name78, values: values78 } = e;
                                        let vec79 = name78;
                                        let ptr79 = vec79.as_ptr().cast::<u8>();
                                        let len79 = vec79.len();
                                        *base.add(12).cast::<usize>() = len79;
                                        *base.add(8).cast::<*mut u8>() = ptr79.cast_mut();
                                        let vec80 = values78;
                                        let len80 = vec80.len();
                                        let layout80 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec80.len() * 4,
                                            4,
                                        );
                                        let result80 = if layout80.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout80).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout80);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec80.into_iter().enumerate() {
                                            let base = result80.add(i * 4);
                                            {
                                                *base.add(0).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                        }
                                        *base.add(20).cast::<usize>() = len80;
                                        *base.add(16).cast::<*mut u8>() = result80;
                                        cleanup_list.extend_from_slice(&[(result80, layout80)]);
                                    }
                                    DbValue::Domain(e) => {
                                        *base.add(0).cast::<u8>() = (38i32) as u8;
                                        let Domain { name: name81, value: value81 } = e;
                                        let vec82 = name81;
                                        let ptr82 = vec82.as_ptr().cast::<u8>();
                                        let len82 = vec82.len();
                                        *base.add(12).cast::<usize>() = len82;
                                        *base.add(8).cast::<*mut u8>() = ptr82.cast_mut();
                                        *base.add(16).cast::<i32>() = (value81).take_handle()
                                            as i32;
                                    }
                                    DbValue::Array(e) => {
                                        *base.add(0).cast::<u8>() = (39i32) as u8;
                                        let vec83 = e;
                                        let len83 = vec83.len();
                                        let layout83 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec83.len() * 4,
                                            4,
                                        );
                                        let result83 = if layout83.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout83).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout83);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec83.into_iter().enumerate() {
                                            let base = result83.add(i * 4);
                                            {
                                                *base.add(0).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len83;
                                        *base.add(8).cast::<*mut u8>() = result83;
                                        cleanup_list.extend_from_slice(&[(result83, layout83)]);
                                    }
                                    DbValue::Range(e) => {
                                        *base.add(0).cast::<u8>() = (40i32) as u8;
                                        let Range { name: name84, value: value84 } = e;
                                        let vec85 = name84;
                                        let ptr85 = vec85.as_ptr().cast::<u8>();
                                        let len85 = vec85.len();
                                        *base.add(12).cast::<usize>() = len85;
                                        *base.add(8).cast::<*mut u8>() = ptr85.cast_mut();
                                        let ValuesRange { start: start86, end: end86 } = value84;
                                        match start86 {
                                            ValueBound::Included(e) => {
                                                *base.add(16).cast::<u8>() = (0i32) as u8;
                                                *base.add(20).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Excluded(e) => {
                                                *base.add(16).cast::<u8>() = (1i32) as u8;
                                                *base.add(20).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Unbounded => {
                                                *base.add(16).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end86 {
                                            ValueBound::Included(e) => {
                                                *base.add(24).cast::<u8>() = (0i32) as u8;
                                                *base.add(28).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Excluded(e) => {
                                                *base.add(24).cast::<u8>() = (1i32) as u8;
                                                *base.add(28).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Unbounded => {
                                                *base.add(24).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Null => {
                                        *base.add(0).cast::<u8>() = (41i32) as u8;
                                    }
                                }
                            }
                        }
                        let ptr88 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rdbms/postgres@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-transaction.query"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            result87,
                            len87,
                            ptr88,
                        );
                        let l89 = i32::from(*ptr88.add(0).cast::<u8>());
                        if layout87.size() != 0 {
                            _rt::alloc::dealloc(result87.cast(), layout87);
                        }
                        for (ptr, layout) in cleanup_list {
                            if layout.size() != 0 {
                                _rt::alloc::dealloc(ptr.cast(), layout);
                            }
                        }
                        match l89 {
                            0 => {
                                let e = {
                                    let l90 = *ptr88.add(4).cast::<*mut u8>();
                                    let l91 = *ptr88.add(8).cast::<usize>();
                                    let base123 = l90;
                                    let len123 = l91;
                                    let mut result123 = _rt::Vec::with_capacity(len123);
                                    for i in 0..len123 {
                                        let base = base123.add(i * 48);
                                        let e123 = {
                                            let l92 = *base.add(0).cast::<i64>();
                                            let l93 = *base.add(8).cast::<*mut u8>();
                                            let l94 = *base.add(12).cast::<usize>();
                                            let len95 = l94;
                                            let bytes95 = _rt::Vec::from_raw_parts(
                                                l93.cast(),
                                                len95,
                                                len95,
                                            );
                                            let l96 = i32::from(*base.add(16).cast::<u8>());
                                            let v119 = match l96 {
                                                0 => DbColumnType::Character,
                                                1 => DbColumnType::Int2,
                                                2 => DbColumnType::Int4,
                                                3 => DbColumnType::Int8,
                                                4 => DbColumnType::Float4,
                                                5 => DbColumnType::Float8,
                                                6 => DbColumnType::Numeric,
                                                7 => DbColumnType::Boolean,
                                                8 => DbColumnType::Text,
                                                9 => DbColumnType::Varchar,
                                                10 => DbColumnType::Bpchar,
                                                11 => DbColumnType::Timestamp,
                                                12 => DbColumnType::Timestamptz,
                                                13 => DbColumnType::Date,
                                                14 => DbColumnType::Time,
                                                15 => DbColumnType::Timetz,
                                                16 => DbColumnType::Interval,
                                                17 => DbColumnType::Bytea,
                                                18 => DbColumnType::Uuid,
                                                19 => DbColumnType::Xml,
                                                20 => DbColumnType::Json,
                                                21 => DbColumnType::Jsonb,
                                                22 => DbColumnType::Jsonpath,
                                                23 => DbColumnType::Inet,
                                                24 => DbColumnType::Cidr,
                                                25 => DbColumnType::Macaddr,
                                                26 => DbColumnType::Bit,
                                                27 => DbColumnType::Varbit,
                                                28 => DbColumnType::Int4range,
                                                29 => DbColumnType::Int8range,
                                                30 => DbColumnType::Numrange,
                                                31 => DbColumnType::Tsrange,
                                                32 => DbColumnType::Tstzrange,
                                                33 => DbColumnType::Daterange,
                                                34 => DbColumnType::Money,
                                                35 => DbColumnType::Oid,
                                                36 => {
                                                    let e119 = {
                                                        let l97 = *base.add(20).cast::<*mut u8>();
                                                        let l98 = *base.add(24).cast::<usize>();
                                                        let len99 = l98;
                                                        let bytes99 = _rt::Vec::from_raw_parts(
                                                            l97.cast(),
                                                            len99,
                                                            len99,
                                                        );
                                                        EnumerationType {
                                                            name: _rt::string_lift(bytes99),
                                                        }
                                                    };
                                                    DbColumnType::Enumeration(e119)
                                                }
                                                37 => {
                                                    let e119 = {
                                                        let l100 = *base.add(20).cast::<*mut u8>();
                                                        let l101 = *base.add(24).cast::<usize>();
                                                        let len102 = l101;
                                                        let bytes102 = _rt::Vec::from_raw_parts(
                                                            l100.cast(),
                                                            len102,
                                                            len102,
                                                        );
                                                        let l103 = *base.add(28).cast::<*mut u8>();
                                                        let l104 = *base.add(32).cast::<usize>();
                                                        let base109 = l103;
                                                        let len109 = l104;
                                                        let mut result109 = _rt::Vec::with_capacity(len109);
                                                        for i in 0..len109 {
                                                            let base = base109.add(i * 12);
                                                            let e109 = {
                                                                let l105 = *base.add(0).cast::<*mut u8>();
                                                                let l106 = *base.add(4).cast::<usize>();
                                                                let len107 = l106;
                                                                let bytes107 = _rt::Vec::from_raw_parts(
                                                                    l105.cast(),
                                                                    len107,
                                                                    len107,
                                                                );
                                                                let l108 = *base.add(8).cast::<i32>();
                                                                (
                                                                    _rt::string_lift(bytes107),
                                                                    LazyDbColumnType::from_handle(l108 as u32),
                                                                )
                                                            };
                                                            result109.push(e109);
                                                        }
                                                        _rt::cabi_dealloc(base109, len109 * 12, 4);
                                                        CompositeType {
                                                            name: _rt::string_lift(bytes102),
                                                            attributes: result109,
                                                        }
                                                    };
                                                    DbColumnType::Composite(e119)
                                                }
                                                38 => {
                                                    let e119 = {
                                                        let l110 = *base.add(20).cast::<*mut u8>();
                                                        let l111 = *base.add(24).cast::<usize>();
                                                        let len112 = l111;
                                                        let bytes112 = _rt::Vec::from_raw_parts(
                                                            l110.cast(),
                                                            len112,
                                                            len112,
                                                        );
                                                        let l113 = *base.add(28).cast::<i32>();
                                                        DomainType {
                                                            name: _rt::string_lift(bytes112),
                                                            base_type: LazyDbColumnType::from_handle(l113 as u32),
                                                        }
                                                    };
                                                    DbColumnType::Domain(e119)
                                                }
                                                39 => {
                                                    let e119 = {
                                                        let l114 = *base.add(20).cast::<i32>();
                                                        LazyDbColumnType::from_handle(l114 as u32)
                                                    };
                                                    DbColumnType::Array(e119)
                                                }
                                                n => {
                                                    debug_assert_eq!(n, 40, "invalid enum discriminant");
                                                    let e119 = {
                                                        let l115 = *base.add(20).cast::<*mut u8>();
                                                        let l116 = *base.add(24).cast::<usize>();
                                                        let len117 = l116;
                                                        let bytes117 = _rt::Vec::from_raw_parts(
                                                            l115.cast(),
                                                            len117,
                                                            len117,
                                                        );
                                                        let l118 = *base.add(28).cast::<i32>();
                                                        RangeType {
                                                            name: _rt::string_lift(bytes117),
                                                            base_type: LazyDbColumnType::from_handle(l118 as u32),
                                                        }
                                                    };
                                                    DbColumnType::Range(e119)
                                                }
                                            };
                                            let l120 = *base.add(36).cast::<*mut u8>();
                                            let l121 = *base.add(40).cast::<usize>();
                                            let len122 = l121;
                                            let bytes122 = _rt::Vec::from_raw_parts(
                                                l120.cast(),
                                                len122,
                                                len122,
                                            );
                                            DbColumn {
                                                ordinal: l92 as u64,
                                                name: _rt::string_lift(bytes95),
                                                db_type: v119,
                                                db_type_name: _rt::string_lift(bytes122),
                                            }
                                        };
                                        result123.push(e123);
                                    }
                                    _rt::cabi_dealloc(base123, len123 * 48, 8);
                                    let l124 = *ptr88.add(12).cast::<*mut u8>();
                                    let l125 = *ptr88.add(16).cast::<usize>();
                                    let base389 = l124;
                                    let len389 = l125;
                                    let mut result389 = _rt::Vec::with_capacity(len389);
                                    for i in 0..len389 {
                                        let base = base389.add(i * 8);
                                        let e389 = {
                                            let l126 = *base.add(0).cast::<*mut u8>();
                                            let l127 = *base.add(4).cast::<usize>();
                                            let base388 = l126;
                                            let len388 = l127;
                                            let mut result388 = _rt::Vec::with_capacity(len388);
                                            for i in 0..len388 {
                                                let base = base388.add(i * 56);
                                                let e388 = {
                                                    let l128 = i32::from(*base.add(0).cast::<u8>());
                                                    let v387 = match l128 {
                                                        0 => {
                                                            let e387 = {
                                                                let l129 = i32::from(*base.add(8).cast::<i8>());
                                                                l129 as i8
                                                            };
                                                            DbValue::Character(e387)
                                                        }
                                                        1 => {
                                                            let e387 = {
                                                                let l130 = i32::from(*base.add(8).cast::<i16>());
                                                                l130 as i16
                                                            };
                                                            DbValue::Int2(e387)
                                                        }
                                                        2 => {
                                                            let e387 = {
                                                                let l131 = *base.add(8).cast::<i32>();
                                                                l131
                                                            };
                                                            DbValue::Int4(e387)
                                                        }
                                                        3 => {
                                                            let e387 = {
                                                                let l132 = *base.add(8).cast::<i64>();
                                                                l132
                                                            };
                                                            DbValue::Int8(e387)
                                                        }
                                                        4 => {
                                                            let e387 = {
                                                                let l133 = *base.add(8).cast::<f32>();
                                                                l133
                                                            };
                                                            DbValue::Float4(e387)
                                                        }
                                                        5 => {
                                                            let e387 = {
                                                                let l134 = *base.add(8).cast::<f64>();
                                                                l134
                                                            };
                                                            DbValue::Float8(e387)
                                                        }
                                                        6 => {
                                                            let e387 = {
                                                                let l135 = *base.add(8).cast::<*mut u8>();
                                                                let l136 = *base.add(12).cast::<usize>();
                                                                let len137 = l136;
                                                                let bytes137 = _rt::Vec::from_raw_parts(
                                                                    l135.cast(),
                                                                    len137,
                                                                    len137,
                                                                );
                                                                _rt::string_lift(bytes137)
                                                            };
                                                            DbValue::Numeric(e387)
                                                        }
                                                        7 => {
                                                            let e387 = {
                                                                let l138 = i32::from(*base.add(8).cast::<u8>());
                                                                _rt::bool_lift(l138 as u8)
                                                            };
                                                            DbValue::Boolean(e387)
                                                        }
                                                        8 => {
                                                            let e387 = {
                                                                let l139 = *base.add(8).cast::<*mut u8>();
                                                                let l140 = *base.add(12).cast::<usize>();
                                                                let len141 = l140;
                                                                let bytes141 = _rt::Vec::from_raw_parts(
                                                                    l139.cast(),
                                                                    len141,
                                                                    len141,
                                                                );
                                                                _rt::string_lift(bytes141)
                                                            };
                                                            DbValue::Text(e387)
                                                        }
                                                        9 => {
                                                            let e387 = {
                                                                let l142 = *base.add(8).cast::<*mut u8>();
                                                                let l143 = *base.add(12).cast::<usize>();
                                                                let len144 = l143;
                                                                let bytes144 = _rt::Vec::from_raw_parts(
                                                                    l142.cast(),
                                                                    len144,
                                                                    len144,
                                                                );
                                                                _rt::string_lift(bytes144)
                                                            };
                                                            DbValue::Varchar(e387)
                                                        }
                                                        10 => {
                                                            let e387 = {
                                                                let l145 = *base.add(8).cast::<*mut u8>();
                                                                let l146 = *base.add(12).cast::<usize>();
                                                                let len147 = l146;
                                                                let bytes147 = _rt::Vec::from_raw_parts(
                                                                    l145.cast(),
                                                                    len147,
                                                                    len147,
                                                                );
                                                                _rt::string_lift(bytes147)
                                                            };
                                                            DbValue::Bpchar(e387)
                                                        }
                                                        11 => {
                                                            let e387 = {
                                                                let l148 = *base.add(8).cast::<i32>();
                                                                let l149 = i32::from(*base.add(12).cast::<u8>());
                                                                let l150 = i32::from(*base.add(13).cast::<u8>());
                                                                let l151 = i32::from(*base.add(16).cast::<u8>());
                                                                let l152 = i32::from(*base.add(17).cast::<u8>());
                                                                let l153 = i32::from(*base.add(18).cast::<u8>());
                                                                let l154 = *base.add(20).cast::<i32>();
                                                                super::super::super::golem::rdbms::types::Timestamp {
                                                                    date: super::super::super::golem::rdbms::types::Date {
                                                                        year: l148,
                                                                        month: l149 as u8,
                                                                        day: l150 as u8,
                                                                    },
                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                        hour: l151 as u8,
                                                                        minute: l152 as u8,
                                                                        second: l153 as u8,
                                                                        nanosecond: l154 as u32,
                                                                    },
                                                                }
                                                            };
                                                            DbValue::Timestamp(e387)
                                                        }
                                                        12 => {
                                                            let e387 = {
                                                                let l155 = *base.add(8).cast::<i32>();
                                                                let l156 = i32::from(*base.add(12).cast::<u8>());
                                                                let l157 = i32::from(*base.add(13).cast::<u8>());
                                                                let l158 = i32::from(*base.add(16).cast::<u8>());
                                                                let l159 = i32::from(*base.add(17).cast::<u8>());
                                                                let l160 = i32::from(*base.add(18).cast::<u8>());
                                                                let l161 = *base.add(20).cast::<i32>();
                                                                let l162 = *base.add(24).cast::<i32>();
                                                                super::super::super::golem::rdbms::types::Timestamptz {
                                                                    timestamp: super::super::super::golem::rdbms::types::Timestamp {
                                                                        date: super::super::super::golem::rdbms::types::Date {
                                                                            year: l155,
                                                                            month: l156 as u8,
                                                                            day: l157 as u8,
                                                                        },
                                                                        time: super::super::super::golem::rdbms::types::Time {
                                                                            hour: l158 as u8,
                                                                            minute: l159 as u8,
                                                                            second: l160 as u8,
                                                                            nanosecond: l161 as u32,
                                                                        },
                                                                    },
                                                                    offset: l162,
                                                                }
                                                            };
                                                            DbValue::Timestamptz(e387)
                                                        }
                                                        13 => {
                                                            let e387 = {
                                                                let l163 = *base.add(8).cast::<i32>();
                                                                let l164 = i32::from(*base.add(12).cast::<u8>());
                                                                let l165 = i32::from(*base.add(13).cast::<u8>());
                                                                super::super::super::golem::rdbms::types::Date {
                                                                    year: l163,
                                                                    month: l164 as u8,
                                                                    day: l165 as u8,
                                                                }
                                                            };
                                                            DbValue::Date(e387)
                                                        }
                                                        14 => {
                                                            let e387 = {
                                                                let l166 = i32::from(*base.add(8).cast::<u8>());
                                                                let l167 = i32::from(*base.add(9).cast::<u8>());
                                                                let l168 = i32::from(*base.add(10).cast::<u8>());
                                                                let l169 = *base.add(12).cast::<i32>();
                                                                super::super::super::golem::rdbms::types::Time {
                                                                    hour: l166 as u8,
                                                                    minute: l167 as u8,
                                                                    second: l168 as u8,
                                                                    nanosecond: l169 as u32,
                                                                }
                                                            };
                                                            DbValue::Time(e387)
                                                        }
                                                        15 => {
                                                            let e387 = {
                                                                let l170 = i32::from(*base.add(8).cast::<u8>());
                                                                let l171 = i32::from(*base.add(9).cast::<u8>());
                                                                let l172 = i32::from(*base.add(10).cast::<u8>());
                                                                let l173 = *base.add(12).cast::<i32>();
                                                                let l174 = *base.add(16).cast::<i32>();
                                                                super::super::super::golem::rdbms::types::Timetz {
                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                        hour: l170 as u8,
                                                                        minute: l171 as u8,
                                                                        second: l172 as u8,
                                                                        nanosecond: l173 as u32,
                                                                    },
                                                                    offset: l174,
                                                                }
                                                            };
                                                            DbValue::Timetz(e387)
                                                        }
                                                        16 => {
                                                            let e387 = {
                                                                let l175 = *base.add(8).cast::<i32>();
                                                                let l176 = *base.add(12).cast::<i32>();
                                                                let l177 = *base.add(16).cast::<i64>();
                                                                Interval {
                                                                    months: l175,
                                                                    days: l176,
                                                                    microseconds: l177,
                                                                }
                                                            };
                                                            DbValue::Interval(e387)
                                                        }
                                                        17 => {
                                                            let e387 = {
                                                                let l178 = *base.add(8).cast::<*mut u8>();
                                                                let l179 = *base.add(12).cast::<usize>();
                                                                let len180 = l179;
                                                                _rt::Vec::from_raw_parts(l178.cast(), len180, len180)
                                                            };
                                                            DbValue::Bytea(e387)
                                                        }
                                                        18 => {
                                                            let e387 = {
                                                                let l181 = *base.add(8).cast::<*mut u8>();
                                                                let l182 = *base.add(12).cast::<usize>();
                                                                let len183 = l182;
                                                                let bytes183 = _rt::Vec::from_raw_parts(
                                                                    l181.cast(),
                                                                    len183,
                                                                    len183,
                                                                );
                                                                _rt::string_lift(bytes183)
                                                            };
                                                            DbValue::Json(e387)
                                                        }
                                                        19 => {
                                                            let e387 = {
                                                                let l184 = *base.add(8).cast::<*mut u8>();
                                                                let l185 = *base.add(12).cast::<usize>();
                                                                let len186 = l185;
                                                                let bytes186 = _rt::Vec::from_raw_parts(
                                                                    l184.cast(),
                                                                    len186,
                                                                    len186,
                                                                );
                                                                _rt::string_lift(bytes186)
                                                            };
                                                            DbValue::Jsonb(e387)
                                                        }
                                                        20 => {
                                                            let e387 = {
                                                                let l187 = *base.add(8).cast::<*mut u8>();
                                                                let l188 = *base.add(12).cast::<usize>();
                                                                let len189 = l188;
                                                                let bytes189 = _rt::Vec::from_raw_parts(
                                                                    l187.cast(),
                                                                    len189,
                                                                    len189,
                                                                );
                                                                _rt::string_lift(bytes189)
                                                            };
                                                            DbValue::Jsonpath(e387)
                                                        }
                                                        21 => {
                                                            let e387 = {
                                                                let l190 = *base.add(8).cast::<*mut u8>();
                                                                let l191 = *base.add(12).cast::<usize>();
                                                                let len192 = l191;
                                                                let bytes192 = _rt::Vec::from_raw_parts(
                                                                    l190.cast(),
                                                                    len192,
                                                                    len192,
                                                                );
                                                                _rt::string_lift(bytes192)
                                                            };
                                                            DbValue::Xml(e387)
                                                        }
                                                        22 => {
                                                            let e387 = {
                                                                let l193 = *base.add(8).cast::<i64>();
                                                                let l194 = *base.add(16).cast::<i64>();
                                                                super::super::super::golem::rdbms::types::Uuid {
                                                                    high_bits: l193 as u64,
                                                                    low_bits: l194 as u64,
                                                                }
                                                            };
                                                            DbValue::Uuid(e387)
                                                        }
                                                        23 => {
                                                            let e387 = {
                                                                let l195 = i32::from(*base.add(8).cast::<u8>());
                                                                use super::super::super::golem::rdbms::types::IpAddress as V208;
                                                                let v208 = match l195 {
                                                                    0 => {
                                                                        let e208 = {
                                                                            let l196 = i32::from(*base.add(10).cast::<u8>());
                                                                            let l197 = i32::from(*base.add(11).cast::<u8>());
                                                                            let l198 = i32::from(*base.add(12).cast::<u8>());
                                                                            let l199 = i32::from(*base.add(13).cast::<u8>());
                                                                            (l196 as u8, l197 as u8, l198 as u8, l199 as u8)
                                                                        };
                                                                        V208::Ipv4(e208)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 1, "invalid enum discriminant");
                                                                        let e208 = {
                                                                            let l200 = i32::from(*base.add(10).cast::<u16>());
                                                                            let l201 = i32::from(*base.add(12).cast::<u16>());
                                                                            let l202 = i32::from(*base.add(14).cast::<u16>());
                                                                            let l203 = i32::from(*base.add(16).cast::<u16>());
                                                                            let l204 = i32::from(*base.add(18).cast::<u16>());
                                                                            let l205 = i32::from(*base.add(20).cast::<u16>());
                                                                            let l206 = i32::from(*base.add(22).cast::<u16>());
                                                                            let l207 = i32::from(*base.add(24).cast::<u16>());
                                                                            (
                                                                                l200 as u16,
                                                                                l201 as u16,
                                                                                l202 as u16,
                                                                                l203 as u16,
                                                                                l204 as u16,
                                                                                l205 as u16,
                                                                                l206 as u16,
                                                                                l207 as u16,
                                                                            )
                                                                        };
                                                                        V208::Ipv6(e208)
                                                                    }
                                                                };
                                                                v208
                                                            };
                                                            DbValue::Inet(e387)
                                                        }
                                                        24 => {
                                                            let e387 = {
                                                                let l209 = i32::from(*base.add(8).cast::<u8>());
                                                                use super::super::super::golem::rdbms::types::IpAddress as V222;
                                                                let v222 = match l209 {
                                                                    0 => {
                                                                        let e222 = {
                                                                            let l210 = i32::from(*base.add(10).cast::<u8>());
                                                                            let l211 = i32::from(*base.add(11).cast::<u8>());
                                                                            let l212 = i32::from(*base.add(12).cast::<u8>());
                                                                            let l213 = i32::from(*base.add(13).cast::<u8>());
                                                                            (l210 as u8, l211 as u8, l212 as u8, l213 as u8)
                                                                        };
                                                                        V222::Ipv4(e222)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 1, "invalid enum discriminant");
                                                                        let e222 = {
                                                                            let l214 = i32::from(*base.add(10).cast::<u16>());
                                                                            let l215 = i32::from(*base.add(12).cast::<u16>());
                                                                            let l216 = i32::from(*base.add(14).cast::<u16>());
                                                                            let l217 = i32::from(*base.add(16).cast::<u16>());
                                                                            let l218 = i32::from(*base.add(18).cast::<u16>());
                                                                            let l219 = i32::from(*base.add(20).cast::<u16>());
                                                                            let l220 = i32::from(*base.add(22).cast::<u16>());
                                                                            let l221 = i32::from(*base.add(24).cast::<u16>());
                                                                            (
                                                                                l214 as u16,
                                                                                l215 as u16,
                                                                                l216 as u16,
                                                                                l217 as u16,
                                                                                l218 as u16,
                                                                                l219 as u16,
                                                                                l220 as u16,
                                                                                l221 as u16,
                                                                            )
                                                                        };
                                                                        V222::Ipv6(e222)
                                                                    }
                                                                };
                                                                v222
                                                            };
                                                            DbValue::Cidr(e387)
                                                        }
                                                        25 => {
                                                            let e387 = {
                                                                let l223 = i32::from(*base.add(8).cast::<u8>());
                                                                let l224 = i32::from(*base.add(9).cast::<u8>());
                                                                let l225 = i32::from(*base.add(10).cast::<u8>());
                                                                let l226 = i32::from(*base.add(11).cast::<u8>());
                                                                let l227 = i32::from(*base.add(12).cast::<u8>());
                                                                let l228 = i32::from(*base.add(13).cast::<u8>());
                                                                super::super::super::golem::rdbms::types::MacAddress {
                                                                    octets: (
                                                                        l223 as u8,
                                                                        l224 as u8,
                                                                        l225 as u8,
                                                                        l226 as u8,
                                                                        l227 as u8,
                                                                        l228 as u8,
                                                                    ),
                                                                }
                                                            };
                                                            DbValue::Macaddr(e387)
                                                        }
                                                        26 => {
                                                            let e387 = {
                                                                let l229 = *base.add(8).cast::<*mut u8>();
                                                                let l230 = *base.add(12).cast::<usize>();
                                                                let base232 = l229;
                                                                let len232 = l230;
                                                                let mut result232 = _rt::Vec::with_capacity(len232);
                                                                for i in 0..len232 {
                                                                    let base = base232.add(i * 1);
                                                                    let e232 = {
                                                                        let l231 = i32::from(*base.add(0).cast::<u8>());
                                                                        _rt::bool_lift(l231 as u8)
                                                                    };
                                                                    result232.push(e232);
                                                                }
                                                                _rt::cabi_dealloc(base232, len232 * 1, 1);
                                                                result232
                                                            };
                                                            DbValue::Bit(e387)
                                                        }
                                                        27 => {
                                                            let e387 = {
                                                                let l233 = *base.add(8).cast::<*mut u8>();
                                                                let l234 = *base.add(12).cast::<usize>();
                                                                let base236 = l233;
                                                                let len236 = l234;
                                                                let mut result236 = _rt::Vec::with_capacity(len236);
                                                                for i in 0..len236 {
                                                                    let base = base236.add(i * 1);
                                                                    let e236 = {
                                                                        let l235 = i32::from(*base.add(0).cast::<u8>());
                                                                        _rt::bool_lift(l235 as u8)
                                                                    };
                                                                    result236.push(e236);
                                                                }
                                                                _rt::cabi_dealloc(base236, len236 * 1, 1);
                                                                result236
                                                            };
                                                            DbValue::Varbit(e387)
                                                        }
                                                        28 => {
                                                            let e387 = {
                                                                let l237 = i32::from(*base.add(8).cast::<u8>());
                                                                let v240 = match l237 {
                                                                    0 => {
                                                                        let e240 = {
                                                                            let l238 = *base.add(12).cast::<i32>();
                                                                            l238
                                                                        };
                                                                        Int4bound::Included(e240)
                                                                    }
                                                                    1 => {
                                                                        let e240 = {
                                                                            let l239 = *base.add(12).cast::<i32>();
                                                                            l239
                                                                        };
                                                                        Int4bound::Excluded(e240)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Int4bound::Unbounded
                                                                    }
                                                                };
                                                                let l241 = i32::from(*base.add(16).cast::<u8>());
                                                                let v244 = match l241 {
                                                                    0 => {
                                                                        let e244 = {
                                                                            let l242 = *base.add(20).cast::<i32>();
                                                                            l242
                                                                        };
                                                                        Int4bound::Included(e244)
                                                                    }
                                                                    1 => {
                                                                        let e244 = {
                                                                            let l243 = *base.add(20).cast::<i32>();
                                                                            l243
                                                                        };
                                                                        Int4bound::Excluded(e244)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Int4bound::Unbounded
                                                                    }
                                                                };
                                                                Int4range {
                                                                    start: v240,
                                                                    end: v244,
                                                                }
                                                            };
                                                            DbValue::Int4range(e387)
                                                        }
                                                        29 => {
                                                            let e387 = {
                                                                let l245 = i32::from(*base.add(8).cast::<u8>());
                                                                let v248 = match l245 {
                                                                    0 => {
                                                                        let e248 = {
                                                                            let l246 = *base.add(16).cast::<i64>();
                                                                            l246
                                                                        };
                                                                        Int8bound::Included(e248)
                                                                    }
                                                                    1 => {
                                                                        let e248 = {
                                                                            let l247 = *base.add(16).cast::<i64>();
                                                                            l247
                                                                        };
                                                                        Int8bound::Excluded(e248)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Int8bound::Unbounded
                                                                    }
                                                                };
                                                                let l249 = i32::from(*base.add(24).cast::<u8>());
                                                                let v252 = match l249 {
                                                                    0 => {
                                                                        let e252 = {
                                                                            let l250 = *base.add(32).cast::<i64>();
                                                                            l250
                                                                        };
                                                                        Int8bound::Included(e252)
                                                                    }
                                                                    1 => {
                                                                        let e252 = {
                                                                            let l251 = *base.add(32).cast::<i64>();
                                                                            l251
                                                                        };
                                                                        Int8bound::Excluded(e252)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Int8bound::Unbounded
                                                                    }
                                                                };
                                                                Int8range {
                                                                    start: v248,
                                                                    end: v252,
                                                                }
                                                            };
                                                            DbValue::Int8range(e387)
                                                        }
                                                        30 => {
                                                            let e387 = {
                                                                let l253 = i32::from(*base.add(8).cast::<u8>());
                                                                let v260 = match l253 {
                                                                    0 => {
                                                                        let e260 = {
                                                                            let l254 = *base.add(12).cast::<*mut u8>();
                                                                            let l255 = *base.add(16).cast::<usize>();
                                                                            let len256 = l255;
                                                                            let bytes256 = _rt::Vec::from_raw_parts(
                                                                                l254.cast(),
                                                                                len256,
                                                                                len256,
                                                                            );
                                                                            _rt::string_lift(bytes256)
                                                                        };
                                                                        Numbound::Included(e260)
                                                                    }
                                                                    1 => {
                                                                        let e260 = {
                                                                            let l257 = *base.add(12).cast::<*mut u8>();
                                                                            let l258 = *base.add(16).cast::<usize>();
                                                                            let len259 = l258;
                                                                            let bytes259 = _rt::Vec::from_raw_parts(
                                                                                l257.cast(),
                                                                                len259,
                                                                                len259,
                                                                            );
                                                                            _rt::string_lift(bytes259)
                                                                        };
                                                                        Numbound::Excluded(e260)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Numbound::Unbounded
                                                                    }
                                                                };
                                                                let l261 = i32::from(*base.add(20).cast::<u8>());
                                                                let v268 = match l261 {
                                                                    0 => {
                                                                        let e268 = {
                                                                            let l262 = *base.add(24).cast::<*mut u8>();
                                                                            let l263 = *base.add(28).cast::<usize>();
                                                                            let len264 = l263;
                                                                            let bytes264 = _rt::Vec::from_raw_parts(
                                                                                l262.cast(),
                                                                                len264,
                                                                                len264,
                                                                            );
                                                                            _rt::string_lift(bytes264)
                                                                        };
                                                                        Numbound::Included(e268)
                                                                    }
                                                                    1 => {
                                                                        let e268 = {
                                                                            let l265 = *base.add(24).cast::<*mut u8>();
                                                                            let l266 = *base.add(28).cast::<usize>();
                                                                            let len267 = l266;
                                                                            let bytes267 = _rt::Vec::from_raw_parts(
                                                                                l265.cast(),
                                                                                len267,
                                                                                len267,
                                                                            );
                                                                            _rt::string_lift(bytes267)
                                                                        };
                                                                        Numbound::Excluded(e268)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Numbound::Unbounded
                                                                    }
                                                                };
                                                                Numrange { start: v260, end: v268 }
                                                            };
                                                            DbValue::Numrange(e387)
                                                        }
                                                        31 => {
                                                            let e387 = {
                                                                let l269 = i32::from(*base.add(8).cast::<u8>());
                                                                let v284 = match l269 {
                                                                    0 => {
                                                                        let e284 = {
                                                                            let l270 = *base.add(12).cast::<i32>();
                                                                            let l271 = i32::from(*base.add(16).cast::<u8>());
                                                                            let l272 = i32::from(*base.add(17).cast::<u8>());
                                                                            let l273 = i32::from(*base.add(20).cast::<u8>());
                                                                            let l274 = i32::from(*base.add(21).cast::<u8>());
                                                                            let l275 = i32::from(*base.add(22).cast::<u8>());
                                                                            let l276 = *base.add(24).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamp {
                                                                                date: super::super::super::golem::rdbms::types::Date {
                                                                                    year: l270,
                                                                                    month: l271 as u8,
                                                                                    day: l272 as u8,
                                                                                },
                                                                                time: super::super::super::golem::rdbms::types::Time {
                                                                                    hour: l273 as u8,
                                                                                    minute: l274 as u8,
                                                                                    second: l275 as u8,
                                                                                    nanosecond: l276 as u32,
                                                                                },
                                                                            }
                                                                        };
                                                                        Tsbound::Included(e284)
                                                                    }
                                                                    1 => {
                                                                        let e284 = {
                                                                            let l277 = *base.add(12).cast::<i32>();
                                                                            let l278 = i32::from(*base.add(16).cast::<u8>());
                                                                            let l279 = i32::from(*base.add(17).cast::<u8>());
                                                                            let l280 = i32::from(*base.add(20).cast::<u8>());
                                                                            let l281 = i32::from(*base.add(21).cast::<u8>());
                                                                            let l282 = i32::from(*base.add(22).cast::<u8>());
                                                                            let l283 = *base.add(24).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamp {
                                                                                date: super::super::super::golem::rdbms::types::Date {
                                                                                    year: l277,
                                                                                    month: l278 as u8,
                                                                                    day: l279 as u8,
                                                                                },
                                                                                time: super::super::super::golem::rdbms::types::Time {
                                                                                    hour: l280 as u8,
                                                                                    minute: l281 as u8,
                                                                                    second: l282 as u8,
                                                                                    nanosecond: l283 as u32,
                                                                                },
                                                                            }
                                                                        };
                                                                        Tsbound::Excluded(e284)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Tsbound::Unbounded
                                                                    }
                                                                };
                                                                let l285 = i32::from(*base.add(28).cast::<u8>());
                                                                let v300 = match l285 {
                                                                    0 => {
                                                                        let e300 = {
                                                                            let l286 = *base.add(32).cast::<i32>();
                                                                            let l287 = i32::from(*base.add(36).cast::<u8>());
                                                                            let l288 = i32::from(*base.add(37).cast::<u8>());
                                                                            let l289 = i32::from(*base.add(40).cast::<u8>());
                                                                            let l290 = i32::from(*base.add(41).cast::<u8>());
                                                                            let l291 = i32::from(*base.add(42).cast::<u8>());
                                                                            let l292 = *base.add(44).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamp {
                                                                                date: super::super::super::golem::rdbms::types::Date {
                                                                                    year: l286,
                                                                                    month: l287 as u8,
                                                                                    day: l288 as u8,
                                                                                },
                                                                                time: super::super::super::golem::rdbms::types::Time {
                                                                                    hour: l289 as u8,
                                                                                    minute: l290 as u8,
                                                                                    second: l291 as u8,
                                                                                    nanosecond: l292 as u32,
                                                                                },
                                                                            }
                                                                        };
                                                                        Tsbound::Included(e300)
                                                                    }
                                                                    1 => {
                                                                        let e300 = {
                                                                            let l293 = *base.add(32).cast::<i32>();
                                                                            let l294 = i32::from(*base.add(36).cast::<u8>());
                                                                            let l295 = i32::from(*base.add(37).cast::<u8>());
                                                                            let l296 = i32::from(*base.add(40).cast::<u8>());
                                                                            let l297 = i32::from(*base.add(41).cast::<u8>());
                                                                            let l298 = i32::from(*base.add(42).cast::<u8>());
                                                                            let l299 = *base.add(44).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamp {
                                                                                date: super::super::super::golem::rdbms::types::Date {
                                                                                    year: l293,
                                                                                    month: l294 as u8,
                                                                                    day: l295 as u8,
                                                                                },
                                                                                time: super::super::super::golem::rdbms::types::Time {
                                                                                    hour: l296 as u8,
                                                                                    minute: l297 as u8,
                                                                                    second: l298 as u8,
                                                                                    nanosecond: l299 as u32,
                                                                                },
                                                                            }
                                                                        };
                                                                        Tsbound::Excluded(e300)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Tsbound::Unbounded
                                                                    }
                                                                };
                                                                Tsrange { start: v284, end: v300 }
                                                            };
                                                            DbValue::Tsrange(e387)
                                                        }
                                                        32 => {
                                                            let e387 = {
                                                                let l301 = i32::from(*base.add(8).cast::<u8>());
                                                                let v318 = match l301 {
                                                                    0 => {
                                                                        let e318 = {
                                                                            let l302 = *base.add(12).cast::<i32>();
                                                                            let l303 = i32::from(*base.add(16).cast::<u8>());
                                                                            let l304 = i32::from(*base.add(17).cast::<u8>());
                                                                            let l305 = i32::from(*base.add(20).cast::<u8>());
                                                                            let l306 = i32::from(*base.add(21).cast::<u8>());
                                                                            let l307 = i32::from(*base.add(22).cast::<u8>());
                                                                            let l308 = *base.add(24).cast::<i32>();
                                                                            let l309 = *base.add(28).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamptz {
                                                                                timestamp: super::super::super::golem::rdbms::types::Timestamp {
                                                                                    date: super::super::super::golem::rdbms::types::Date {
                                                                                        year: l302,
                                                                                        month: l303 as u8,
                                                                                        day: l304 as u8,
                                                                                    },
                                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                                        hour: l305 as u8,
                                                                                        minute: l306 as u8,
                                                                                        second: l307 as u8,
                                                                                        nanosecond: l308 as u32,
                                                                                    },
                                                                                },
                                                                                offset: l309,
                                                                            }
                                                                        };
                                                                        Tstzbound::Included(e318)
                                                                    }
                                                                    1 => {
                                                                        let e318 = {
                                                                            let l310 = *base.add(12).cast::<i32>();
                                                                            let l311 = i32::from(*base.add(16).cast::<u8>());
                                                                            let l312 = i32::from(*base.add(17).cast::<u8>());
                                                                            let l313 = i32::from(*base.add(20).cast::<u8>());
                                                                            let l314 = i32::from(*base.add(21).cast::<u8>());
                                                                            let l315 = i32::from(*base.add(22).cast::<u8>());
                                                                            let l316 = *base.add(24).cast::<i32>();
                                                                            let l317 = *base.add(28).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamptz {
                                                                                timestamp: super::super::super::golem::rdbms::types::Timestamp {
                                                                                    date: super::super::super::golem::rdbms::types::Date {
                                                                                        year: l310,
                                                                                        month: l311 as u8,
                                                                                        day: l312 as u8,
                                                                                    },
                                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                                        hour: l313 as u8,
                                                                                        minute: l314 as u8,
                                                                                        second: l315 as u8,
                                                                                        nanosecond: l316 as u32,
                                                                                    },
                                                                                },
                                                                                offset: l317,
                                                                            }
                                                                        };
                                                                        Tstzbound::Excluded(e318)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Tstzbound::Unbounded
                                                                    }
                                                                };
                                                                let l319 = i32::from(*base.add(32).cast::<u8>());
                                                                let v336 = match l319 {
                                                                    0 => {
                                                                        let e336 = {
                                                                            let l320 = *base.add(36).cast::<i32>();
                                                                            let l321 = i32::from(*base.add(40).cast::<u8>());
                                                                            let l322 = i32::from(*base.add(41).cast::<u8>());
                                                                            let l323 = i32::from(*base.add(44).cast::<u8>());
                                                                            let l324 = i32::from(*base.add(45).cast::<u8>());
                                                                            let l325 = i32::from(*base.add(46).cast::<u8>());
                                                                            let l326 = *base.add(48).cast::<i32>();
                                                                            let l327 = *base.add(52).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamptz {
                                                                                timestamp: super::super::super::golem::rdbms::types::Timestamp {
                                                                                    date: super::super::super::golem::rdbms::types::Date {
                                                                                        year: l320,
                                                                                        month: l321 as u8,
                                                                                        day: l322 as u8,
                                                                                    },
                                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                                        hour: l323 as u8,
                                                                                        minute: l324 as u8,
                                                                                        second: l325 as u8,
                                                                                        nanosecond: l326 as u32,
                                                                                    },
                                                                                },
                                                                                offset: l327,
                                                                            }
                                                                        };
                                                                        Tstzbound::Included(e336)
                                                                    }
                                                                    1 => {
                                                                        let e336 = {
                                                                            let l328 = *base.add(36).cast::<i32>();
                                                                            let l329 = i32::from(*base.add(40).cast::<u8>());
                                                                            let l330 = i32::from(*base.add(41).cast::<u8>());
                                                                            let l331 = i32::from(*base.add(44).cast::<u8>());
                                                                            let l332 = i32::from(*base.add(45).cast::<u8>());
                                                                            let l333 = i32::from(*base.add(46).cast::<u8>());
                                                                            let l334 = *base.add(48).cast::<i32>();
                                                                            let l335 = *base.add(52).cast::<i32>();
                                                                            super::super::super::golem::rdbms::types::Timestamptz {
                                                                                timestamp: super::super::super::golem::rdbms::types::Timestamp {
                                                                                    date: super::super::super::golem::rdbms::types::Date {
                                                                                        year: l328,
                                                                                        month: l329 as u8,
                                                                                        day: l330 as u8,
                                                                                    },
                                                                                    time: super::super::super::golem::rdbms::types::Time {
                                                                                        hour: l331 as u8,
                                                                                        minute: l332 as u8,
                                                                                        second: l333 as u8,
                                                                                        nanosecond: l334 as u32,
                                                                                    },
                                                                                },
                                                                                offset: l335,
                                                                            }
                                                                        };
                                                                        Tstzbound::Excluded(e336)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Tstzbound::Unbounded
                                                                    }
                                                                };
                                                                Tstzrange {
                                                                    start: v318,
                                                                    end: v336,
                                                                }
                                                            };
                                                            DbValue::Tstzrange(e387)
                                                        }
                                                        33 => {
                                                            let e387 = {
                                                                let l337 = i32::from(*base.add(8).cast::<u8>());
                                                                let v344 = match l337 {
                                                                    0 => {
                                                                        let e344 = {
                                                                            let l338 = *base.add(12).cast::<i32>();
                                                                            let l339 = i32::from(*base.add(16).cast::<u8>());
                                                                            let l340 = i32::from(*base.add(17).cast::<u8>());
                                                                            super::super::super::golem::rdbms::types::Date {
                                                                                year: l338,
                                                                                month: l339 as u8,
                                                                                day: l340 as u8,
                                                                            }
                                                                        };
                                                                        Datebound::Included(e344)
                                                                    }
                                                                    1 => {
                                                                        let e344 = {
                                                                            let l341 = *base.add(12).cast::<i32>();
                                                                            let l342 = i32::from(*base.add(16).cast::<u8>());
                                                                            let l343 = i32::from(*base.add(17).cast::<u8>());
                                                                            super::super::super::golem::rdbms::types::Date {
                                                                                year: l341,
                                                                                month: l342 as u8,
                                                                                day: l343 as u8,
                                                                            }
                                                                        };
                                                                        Datebound::Excluded(e344)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Datebound::Unbounded
                                                                    }
                                                                };
                                                                let l345 = i32::from(*base.add(20).cast::<u8>());
                                                                let v352 = match l345 {
                                                                    0 => {
                                                                        let e352 = {
                                                                            let l346 = *base.add(24).cast::<i32>();
                                                                            let l347 = i32::from(*base.add(28).cast::<u8>());
                                                                            let l348 = i32::from(*base.add(29).cast::<u8>());
                                                                            super::super::super::golem::rdbms::types::Date {
                                                                                year: l346,
                                                                                month: l347 as u8,
                                                                                day: l348 as u8,
                                                                            }
                                                                        };
                                                                        Datebound::Included(e352)
                                                                    }
                                                                    1 => {
                                                                        let e352 = {
                                                                            let l349 = *base.add(24).cast::<i32>();
                                                                            let l350 = i32::from(*base.add(28).cast::<u8>());
                                                                            let l351 = i32::from(*base.add(29).cast::<u8>());
                                                                            super::super::super::golem::rdbms::types::Date {
                                                                                year: l349,
                                                                                month: l350 as u8,
                                                                                day: l351 as u8,
                                                                            }
                                                                        };
                                                                        Datebound::Excluded(e352)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        Datebound::Unbounded
                                                                    }
                                                                };
                                                                Daterange {
                                                                    start: v344,
                                                                    end: v352,
                                                                }
                                                            };
                                                            DbValue::Daterange(e387)
                                                        }
                                                        34 => {
                                                            let e387 = {
                                                                let l353 = *base.add(8).cast::<i64>();
                                                                l353
                                                            };
                                                            DbValue::Money(e387)
                                                        }
                                                        35 => {
                                                            let e387 = {
                                                                let l354 = *base.add(8).cast::<i32>();
                                                                l354 as u32
                                                            };
                                                            DbValue::Oid(e387)
                                                        }
                                                        36 => {
                                                            let e387 = {
                                                                let l355 = *base.add(8).cast::<*mut u8>();
                                                                let l356 = *base.add(12).cast::<usize>();
                                                                let len357 = l356;
                                                                let bytes357 = _rt::Vec::from_raw_parts(
                                                                    l355.cast(),
                                                                    len357,
                                                                    len357,
                                                                );
                                                                let l358 = *base.add(16).cast::<*mut u8>();
                                                                let l359 = *base.add(20).cast::<usize>();
                                                                let len360 = l359;
                                                                let bytes360 = _rt::Vec::from_raw_parts(
                                                                    l358.cast(),
                                                                    len360,
                                                                    len360,
                                                                );
                                                                Enumeration {
                                                                    name: _rt::string_lift(bytes357),
                                                                    value: _rt::string_lift(bytes360),
                                                                }
                                                            };
                                                            DbValue::Enumeration(e387)
                                                        }
                                                        37 => {
                                                            let e387 = {
                                                                let l361 = *base.add(8).cast::<*mut u8>();
                                                                let l362 = *base.add(12).cast::<usize>();
                                                                let len363 = l362;
                                                                let bytes363 = _rt::Vec::from_raw_parts(
                                                                    l361.cast(),
                                                                    len363,
                                                                    len363,
                                                                );
                                                                let l364 = *base.add(16).cast::<*mut u8>();
                                                                let l365 = *base.add(20).cast::<usize>();
                                                                let base367 = l364;
                                                                let len367 = l365;
                                                                let mut result367 = _rt::Vec::with_capacity(len367);
                                                                for i in 0..len367 {
                                                                    let base = base367.add(i * 4);
                                                                    let e367 = {
                                                                        let l366 = *base.add(0).cast::<i32>();
                                                                        LazyDbValue::from_handle(l366 as u32)
                                                                    };
                                                                    result367.push(e367);
                                                                }
                                                                _rt::cabi_dealloc(base367, len367 * 4, 4);
                                                                Composite {
                                                                    name: _rt::string_lift(bytes363),
                                                                    values: result367,
                                                                }
                                                            };
                                                            DbValue::Composite(e387)
                                                        }
                                                        38 => {
                                                            let e387 = {
                                                                let l368 = *base.add(8).cast::<*mut u8>();
                                                                let l369 = *base.add(12).cast::<usize>();
                                                                let len370 = l369;
                                                                let bytes370 = _rt::Vec::from_raw_parts(
                                                                    l368.cast(),
                                                                    len370,
                                                                    len370,
                                                                );
                                                                let l371 = *base.add(16).cast::<i32>();
                                                                Domain {
                                                                    name: _rt::string_lift(bytes370),
                                                                    value: LazyDbValue::from_handle(l371 as u32),
                                                                }
                                                            };
                                                            DbValue::Domain(e387)
                                                        }
                                                        39 => {
                                                            let e387 = {
                                                                let l372 = *base.add(8).cast::<*mut u8>();
                                                                let l373 = *base.add(12).cast::<usize>();
                                                                let base375 = l372;
                                                                let len375 = l373;
                                                                let mut result375 = _rt::Vec::with_capacity(len375);
                                                                for i in 0..len375 {
                                                                    let base = base375.add(i * 4);
                                                                    let e375 = {
                                                                        let l374 = *base.add(0).cast::<i32>();
                                                                        LazyDbValue::from_handle(l374 as u32)
                                                                    };
                                                                    result375.push(e375);
                                                                }
                                                                _rt::cabi_dealloc(base375, len375 * 4, 4);
                                                                result375
                                                            };
                                                            DbValue::Array(e387)
                                                        }
                                                        40 => {
                                                            let e387 = {
                                                                let l376 = *base.add(8).cast::<*mut u8>();
                                                                let l377 = *base.add(12).cast::<usize>();
                                                                let len378 = l377;
                                                                let bytes378 = _rt::Vec::from_raw_parts(
                                                                    l376.cast(),
                                                                    len378,
                                                                    len378,
                                                                );
                                                                let l379 = i32::from(*base.add(16).cast::<u8>());
                                                                let v382 = match l379 {
                                                                    0 => {
                                                                        let e382 = {
                                                                            let l380 = *base.add(20).cast::<i32>();
                                                                            LazyDbValue::from_handle(l380 as u32)
                                                                        };
                                                                        ValueBound::Included(e382)
                                                                    }
                                                                    1 => {
                                                                        let e382 = {
                                                                            let l381 = *base.add(20).cast::<i32>();
                                                                            LazyDbValue::from_handle(l381 as u32)
                                                                        };
                                                                        ValueBound::Excluded(e382)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        ValueBound::Unbounded
                                                                    }
                                                                };
                                                                let l383 = i32::from(*base.add(24).cast::<u8>());
                                                                let v386 = match l383 {
                                                                    0 => {
                                                                        let e386 = {
                                                                            let l384 = *base.add(28).cast::<i32>();
                                                                            LazyDbValue::from_handle(l384 as u32)
                                                                        };
                                                                        ValueBound::Included(e386)
                                                                    }
                                                                    1 => {
                                                                        let e386 = {
                                                                            let l385 = *base.add(28).cast::<i32>();
                                                                            LazyDbValue::from_handle(l385 as u32)
                                                                        };
                                                                        ValueBound::Excluded(e386)
                                                                    }
                                                                    n => {
                                                                        debug_assert_eq!(n, 2, "invalid enum discriminant");
                                                                        ValueBound::Unbounded
                                                                    }
                                                                };
                                                                Range {
                                                                    name: _rt::string_lift(bytes378),
                                                                    value: ValuesRange {
                                                                        start: v382,
                                                                        end: v386,
                                                                    },
                                                                }
                                                            };
                                                            DbValue::Range(e387)
                                                        }
                                                        n => {
                                                            debug_assert_eq!(n, 41, "invalid enum discriminant");
                                                            DbValue::Null
                                                        }
                                                    };
                                                    v387
                                                };
                                                result388.push(e388);
                                            }
                                            _rt::cabi_dealloc(base388, len388 * 56, 8);
                                            DbRow { values: result388 }
                                        };
                                        result389.push(e389);
                                    }
                                    _rt::cabi_dealloc(base389, len389 * 8, 4);
                                    DbResult {
                                        columns: result123,
                                        rows: result389,
                                    }
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l390 = i32::from(*ptr88.add(4).cast::<u8>());
                                    let v406 = match l390 {
                                        0 => {
                                            let e406 = {
                                                let l391 = *ptr88.add(8).cast::<*mut u8>();
                                                let l392 = *ptr88.add(12).cast::<usize>();
                                                let len393 = l392;
                                                let bytes393 = _rt::Vec::from_raw_parts(
                                                    l391.cast(),
                                                    len393,
                                                    len393,
                                                );
                                                _rt::string_lift(bytes393)
                                            };
                                            Error::ConnectionFailure(e406)
                                        }
                                        1 => {
                                            let e406 = {
                                                let l394 = *ptr88.add(8).cast::<*mut u8>();
                                                let l395 = *ptr88.add(12).cast::<usize>();
                                                let len396 = l395;
                                                let bytes396 = _rt::Vec::from_raw_parts(
                                                    l394.cast(),
                                                    len396,
                                                    len396,
                                                );
                                                _rt::string_lift(bytes396)
                                            };
                                            Error::QueryParameterFailure(e406)
                                        }
                                        2 => {
                                            let e406 = {
                                                let l397 = *ptr88.add(8).cast::<*mut u8>();
                                                let l398 = *ptr88.add(12).cast::<usize>();
                                                let len399 = l398;
                                                let bytes399 = _rt::Vec::from_raw_parts(
                                                    l397.cast(),
                                                    len399,
                                                    len399,
                                                );
                                                _rt::string_lift(bytes399)
                                            };
                                            Error::QueryExecutionFailure(e406)
                                        }
                                        3 => {
                                            let e406 = {
                                                let l400 = *ptr88.add(8).cast::<*mut u8>();
                                                let l401 = *ptr88.add(12).cast::<usize>();
                                                let len402 = l401;
                                                let bytes402 = _rt::Vec::from_raw_parts(
                                                    l400.cast(),
                                                    len402,
                                                    len402,
                                                );
                                                _rt::string_lift(bytes402)
                                            };
                                            Error::QueryResponseFailure(e406)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 4, "invalid enum discriminant");
                                            let e406 = {
                                                let l403 = *ptr88.add(8).cast::<*mut u8>();
                                                let l404 = *ptr88.add(12).cast::<usize>();
                                                let len405 = l404;
                                                let bytes405 = _rt::Vec::from_raw_parts(
                                                    l403.cast(),
                                                    len405,
                                                    len405,
                                                );
                                                _rt::string_lift(bytes405)
                                            };
                                            Error::Other(e406)
                                        }
                                    };
                                    v406
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl DbTransaction {
                #[allow(unused_unsafe, clippy::all)]
                pub fn query_stream(
                    &self,
                    statement: &str,
                    params: _rt::Vec<DbValue>,
                ) -> Result<DbResultStream, Error> {
                    unsafe {
                        let mut cleanup_list = _rt::Vec::new();
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 16]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 16],
                        );
                        let vec0 = statement;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let vec87 = &params;
                        let len87 = vec87.len();
                        let layout87 = _rt::alloc::Layout::from_size_align_unchecked(
                            vec87.len() * 56,
                            8,
                        );
                        let result87 = if layout87.size() != 0 {
                            let ptr = _rt::alloc::alloc(layout87).cast::<u8>();
                            if ptr.is_null() {
                                _rt::alloc::handle_alloc_error(layout87);
                            }
                            ptr
                        } else {
                            ::core::ptr::null_mut()
                        };
                        for (i, e) in vec87.into_iter().enumerate() {
                            let base = result87.add(i * 56);
                            {
                                match e {
                                    DbValue::Character(e) => {
                                        *base.add(0).cast::<u8>() = (0i32) as u8;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                    }
                                    DbValue::Int2(e) => {
                                        *base.add(0).cast::<u8>() = (1i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::Int4(e) => {
                                        *base.add(0).cast::<u8>() = (2i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Int8(e) => {
                                        *base.add(0).cast::<u8>() = (3i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::Float4(e) => {
                                        *base.add(0).cast::<u8>() = (4i32) as u8;
                                        *base.add(8).cast::<f32>() = _rt::as_f32(e);
                                    }
                                    DbValue::Float8(e) => {
                                        *base.add(0).cast::<u8>() = (5i32) as u8;
                                        *base.add(8).cast::<f64>() = _rt::as_f64(e);
                                    }
                                    DbValue::Numeric(e) => {
                                        *base.add(0).cast::<u8>() = (6i32) as u8;
                                        let vec1 = e;
                                        let ptr1 = vec1.as_ptr().cast::<u8>();
                                        let len1 = vec1.len();
                                        *base.add(12).cast::<usize>() = len1;
                                        *base.add(8).cast::<*mut u8>() = ptr1.cast_mut();
                                    }
                                    DbValue::Boolean(e) => {
                                        *base.add(0).cast::<u8>() = (7i32) as u8;
                                        *base.add(8).cast::<u8>() = (match e {
                                            true => 1,
                                            false => 0,
                                        }) as u8;
                                    }
                                    DbValue::Text(e) => {
                                        *base.add(0).cast::<u8>() = (8i32) as u8;
                                        let vec2 = e;
                                        let ptr2 = vec2.as_ptr().cast::<u8>();
                                        let len2 = vec2.len();
                                        *base.add(12).cast::<usize>() = len2;
                                        *base.add(8).cast::<*mut u8>() = ptr2.cast_mut();
                                    }
                                    DbValue::Varchar(e) => {
                                        *base.add(0).cast::<u8>() = (9i32) as u8;
                                        let vec3 = e;
                                        let ptr3 = vec3.as_ptr().cast::<u8>();
                                        let len3 = vec3.len();
                                        *base.add(12).cast::<usize>() = len3;
                                        *base.add(8).cast::<*mut u8>() = ptr3.cast_mut();
                                    }
                                    DbValue::Bpchar(e) => {
                                        *base.add(0).cast::<u8>() = (10i32) as u8;
                                        let vec4 = e;
                                        let ptr4 = vec4.as_ptr().cast::<u8>();
                                        let len4 = vec4.len();
                                        *base.add(12).cast::<usize>() = len4;
                                        *base.add(8).cast::<*mut u8>() = ptr4.cast_mut();
                                    }
                                    DbValue::Timestamp(e) => {
                                        *base.add(0).cast::<u8>() = (11i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date5,
                                            time: time5,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year6,
                                            month: month6,
                                            day: day6,
                                        } = date5;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year6);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month6)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day6)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour7,
                                            minute: minute7,
                                            second: second7,
                                            nanosecond: nanosecond7,
                                        } = time5;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour7)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute7)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second7)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond7);
                                    }
                                    DbValue::Timestamptz(e) => {
                                        *base.add(0).cast::<u8>() = (12i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamptz {
                                            timestamp: timestamp8,
                                            offset: offset8,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date9,
                                            time: time9,
                                        } = timestamp8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year10,
                                            month: month10,
                                            day: day10,
                                        } = date9;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year10);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month10)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day10)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour11,
                                            minute: minute11,
                                            second: second11,
                                            nanosecond: nanosecond11,
                                        } = time9;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour11)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute11)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second11)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond11);
                                        *base.add(24).cast::<i32>() = _rt::as_i32(offset8);
                                    }
                                    DbValue::Date(e) => {
                                        *base.add(0).cast::<u8>() = (13i32) as u8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year12,
                                            month: month12,
                                            day: day12,
                                        } = e;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year12);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month12)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day12)) as u8;
                                    }
                                    DbValue::Time(e) => {
                                        *base.add(0).cast::<u8>() = (14i32) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour13,
                                            minute: minute13,
                                            second: second13,
                                            nanosecond: nanosecond13,
                                        } = e;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(hour13)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(minute13)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(second13)) as u8;
                                        *base.add(12).cast::<i32>() = _rt::as_i32(nanosecond13);
                                    }
                                    DbValue::Timetz(e) => {
                                        *base.add(0).cast::<u8>() = (15i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timetz {
                                            time: time14,
                                            offset: offset14,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour15,
                                            minute: minute15,
                                            second: second15,
                                            nanosecond: nanosecond15,
                                        } = time14;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(hour15)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(minute15)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(second15)) as u8;
                                        *base.add(12).cast::<i32>() = _rt::as_i32(nanosecond15);
                                        *base.add(16).cast::<i32>() = _rt::as_i32(offset14);
                                    }
                                    DbValue::Interval(e) => {
                                        *base.add(0).cast::<u8>() = (16i32) as u8;
                                        let Interval {
                                            months: months16,
                                            days: days16,
                                            microseconds: microseconds16,
                                        } = e;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(months16);
                                        *base.add(12).cast::<i32>() = _rt::as_i32(days16);
                                        *base.add(16).cast::<i64>() = _rt::as_i64(microseconds16);
                                    }
                                    DbValue::Bytea(e) => {
                                        *base.add(0).cast::<u8>() = (17i32) as u8;
                                        let vec17 = e;
                                        let ptr17 = vec17.as_ptr().cast::<u8>();
                                        let len17 = vec17.len();
                                        *base.add(12).cast::<usize>() = len17;
                                        *base.add(8).cast::<*mut u8>() = ptr17.cast_mut();
                                    }
                                    DbValue::Json(e) => {
                                        *base.add(0).cast::<u8>() = (18i32) as u8;
                                        let vec18 = e;
                                        let ptr18 = vec18.as_ptr().cast::<u8>();
                                        let len18 = vec18.len();
                                        *base.add(12).cast::<usize>() = len18;
                                        *base.add(8).cast::<*mut u8>() = ptr18.cast_mut();
                                    }
                                    DbValue::Jsonb(e) => {
                                        *base.add(0).cast::<u8>() = (19i32) as u8;
                                        let vec19 = e;
                                        let ptr19 = vec19.as_ptr().cast::<u8>();
                                        let len19 = vec19.len();
                                        *base.add(12).cast::<usize>() = len19;
                                        *base.add(8).cast::<*mut u8>() = ptr19.cast_mut();
                                    }
                                    DbValue::Jsonpath(e) => {
                                        *base.add(0).cast::<u8>() = (20i32) as u8;
                                        let vec20 = e;
                                        let ptr20 = vec20.as_ptr().cast::<u8>();
                                        let len20 = vec20.len();
                                        *base.add(12).cast::<usize>() = len20;
                                        *base.add(8).cast::<*mut u8>() = ptr20.cast_mut();
                                    }
                                    DbValue::Xml(e) => {
                                        *base.add(0).cast::<u8>() = (21i32) as u8;
                                        let vec21 = e;
                                        let ptr21 = vec21.as_ptr().cast::<u8>();
                                        let len21 = vec21.len();
                                        *base.add(12).cast::<usize>() = len21;
                                        *base.add(8).cast::<*mut u8>() = ptr21.cast_mut();
                                    }
                                    DbValue::Uuid(e) => {
                                        *base.add(0).cast::<u8>() = (22i32) as u8;
                                        let super::super::super::golem::rdbms::types::Uuid {
                                            high_bits: high_bits22,
                                            low_bits: low_bits22,
                                        } = e;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(high_bits22);
                                        *base.add(16).cast::<i64>() = _rt::as_i64(low_bits22);
                                    }
                                    DbValue::Inet(e) => {
                                        *base.add(0).cast::<u8>() = (23i32) as u8;
                                        use super::super::super::golem::rdbms::types::IpAddress as V25;
                                        match e {
                                            V25::Ipv4(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let (t23_0, t23_1, t23_2, t23_3) = e;
                                                *base.add(10).cast::<u8>() = (_rt::as_i32(t23_0)) as u8;
                                                *base.add(11).cast::<u8>() = (_rt::as_i32(t23_1)) as u8;
                                                *base.add(12).cast::<u8>() = (_rt::as_i32(t23_2)) as u8;
                                                *base.add(13).cast::<u8>() = (_rt::as_i32(t23_3)) as u8;
                                            }
                                            V25::Ipv6(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let (
                                                    t24_0,
                                                    t24_1,
                                                    t24_2,
                                                    t24_3,
                                                    t24_4,
                                                    t24_5,
                                                    t24_6,
                                                    t24_7,
                                                ) = e;
                                                *base.add(10).cast::<u16>() = (_rt::as_i32(t24_0)) as u16;
                                                *base.add(12).cast::<u16>() = (_rt::as_i32(t24_1)) as u16;
                                                *base.add(14).cast::<u16>() = (_rt::as_i32(t24_2)) as u16;
                                                *base.add(16).cast::<u16>() = (_rt::as_i32(t24_3)) as u16;
                                                *base.add(18).cast::<u16>() = (_rt::as_i32(t24_4)) as u16;
                                                *base.add(20).cast::<u16>() = (_rt::as_i32(t24_5)) as u16;
                                                *base.add(22).cast::<u16>() = (_rt::as_i32(t24_6)) as u16;
                                                *base.add(24).cast::<u16>() = (_rt::as_i32(t24_7)) as u16;
                                            }
                                        }
                                    }
                                    DbValue::Cidr(e) => {
                                        *base.add(0).cast::<u8>() = (24i32) as u8;
                                        use super::super::super::golem::rdbms::types::IpAddress as V28;
                                        match e {
                                            V28::Ipv4(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let (t26_0, t26_1, t26_2, t26_3) = e;
                                                *base.add(10).cast::<u8>() = (_rt::as_i32(t26_0)) as u8;
                                                *base.add(11).cast::<u8>() = (_rt::as_i32(t26_1)) as u8;
                                                *base.add(12).cast::<u8>() = (_rt::as_i32(t26_2)) as u8;
                                                *base.add(13).cast::<u8>() = (_rt::as_i32(t26_3)) as u8;
                                            }
                                            V28::Ipv6(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let (
                                                    t27_0,
                                                    t27_1,
                                                    t27_2,
                                                    t27_3,
                                                    t27_4,
                                                    t27_5,
                                                    t27_6,
                                                    t27_7,
                                                ) = e;
                                                *base.add(10).cast::<u16>() = (_rt::as_i32(t27_0)) as u16;
                                                *base.add(12).cast::<u16>() = (_rt::as_i32(t27_1)) as u16;
                                                *base.add(14).cast::<u16>() = (_rt::as_i32(t27_2)) as u16;
                                                *base.add(16).cast::<u16>() = (_rt::as_i32(t27_3)) as u16;
                                                *base.add(18).cast::<u16>() = (_rt::as_i32(t27_4)) as u16;
                                                *base.add(20).cast::<u16>() = (_rt::as_i32(t27_5)) as u16;
                                                *base.add(22).cast::<u16>() = (_rt::as_i32(t27_6)) as u16;
                                                *base.add(24).cast::<u16>() = (_rt::as_i32(t27_7)) as u16;
                                            }
                                        }
                                    }
                                    DbValue::Macaddr(e) => {
                                        *base.add(0).cast::<u8>() = (25i32) as u8;
                                        let super::super::super::golem::rdbms::types::MacAddress {
                                            octets: octets29,
                                        } = e;
                                        let (t30_0, t30_1, t30_2, t30_3, t30_4, t30_5) = octets29;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(t30_0)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(t30_1)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(t30_2)) as u8;
                                        *base.add(11).cast::<u8>() = (_rt::as_i32(t30_3)) as u8;
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(t30_4)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(t30_5)) as u8;
                                    }
                                    DbValue::Bit(e) => {
                                        *base.add(0).cast::<u8>() = (26i32) as u8;
                                        let vec31 = e;
                                        let len31 = vec31.len();
                                        let layout31 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec31.len() * 1,
                                            1,
                                        );
                                        let result31 = if layout31.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout31).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout31);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec31.into_iter().enumerate() {
                                            let base = result31.add(i * 1);
                                            {
                                                *base.add(0).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len31;
                                        *base.add(8).cast::<*mut u8>() = result31;
                                        cleanup_list.extend_from_slice(&[(result31, layout31)]);
                                    }
                                    DbValue::Varbit(e) => {
                                        *base.add(0).cast::<u8>() = (27i32) as u8;
                                        let vec32 = e;
                                        let len32 = vec32.len();
                                        let layout32 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec32.len() * 1,
                                            1,
                                        );
                                        let result32 = if layout32.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout32).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout32);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec32.into_iter().enumerate() {
                                            let base = result32.add(i * 1);
                                            {
                                                *base.add(0).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len32;
                                        *base.add(8).cast::<*mut u8>() = result32;
                                        cleanup_list.extend_from_slice(&[(result32, layout32)]);
                                    }
                                    DbValue::Int4range(e) => {
                                        *base.add(0).cast::<u8>() = (28i32) as u8;
                                        let Int4range { start: start33, end: end33 } = e;
                                        match start33 {
                                            Int4bound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end33 {
                                            Int4bound::Included(e) => {
                                                *base.add(16).cast::<u8>() = (0i32) as u8;
                                                *base.add(20).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Excluded(e) => {
                                                *base.add(16).cast::<u8>() = (1i32) as u8;
                                                *base.add(20).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Unbounded => {
                                                *base.add(16).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Int8range(e) => {
                                        *base.add(0).cast::<u8>() = (29i32) as u8;
                                        let Int8range { start: start34, end: end34 } = e;
                                        match start34 {
                                            Int8bound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                *base.add(16).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                *base.add(16).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end34 {
                                            Int8bound::Included(e) => {
                                                *base.add(24).cast::<u8>() = (0i32) as u8;
                                                *base.add(32).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Excluded(e) => {
                                                *base.add(24).cast::<u8>() = (1i32) as u8;
                                                *base.add(32).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Unbounded => {
                                                *base.add(24).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Numrange(e) => {
                                        *base.add(0).cast::<u8>() = (30i32) as u8;
                                        let Numrange { start: start35, end: end35 } = e;
                                        match start35 {
                                            Numbound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let vec36 = e;
                                                let ptr36 = vec36.as_ptr().cast::<u8>();
                                                let len36 = vec36.len();
                                                *base.add(16).cast::<usize>() = len36;
                                                *base.add(12).cast::<*mut u8>() = ptr36.cast_mut();
                                            }
                                            Numbound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let vec37 = e;
                                                let ptr37 = vec37.as_ptr().cast::<u8>();
                                                let len37 = vec37.len();
                                                *base.add(16).cast::<usize>() = len37;
                                                *base.add(12).cast::<*mut u8>() = ptr37.cast_mut();
                                            }
                                            Numbound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end35 {
                                            Numbound::Included(e) => {
                                                *base.add(20).cast::<u8>() = (0i32) as u8;
                                                let vec38 = e;
                                                let ptr38 = vec38.as_ptr().cast::<u8>();
                                                let len38 = vec38.len();
                                                *base.add(28).cast::<usize>() = len38;
                                                *base.add(24).cast::<*mut u8>() = ptr38.cast_mut();
                                            }
                                            Numbound::Excluded(e) => {
                                                *base.add(20).cast::<u8>() = (1i32) as u8;
                                                let vec39 = e;
                                                let ptr39 = vec39.as_ptr().cast::<u8>();
                                                let len39 = vec39.len();
                                                *base.add(28).cast::<usize>() = len39;
                                                *base.add(24).cast::<*mut u8>() = ptr39.cast_mut();
                                            }
                                            Numbound::Unbounded => {
                                                *base.add(20).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Tsrange(e) => {
                                        *base.add(0).cast::<u8>() = (31i32) as u8;
                                        let Tsrange { start: start40, end: end40 } = e;
                                        match start40 {
                                            Tsbound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date41,
                                                    time: time41,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year42,
                                                    month: month42,
                                                    day: day42,
                                                } = date41;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year42);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month42)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day42)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour43,
                                                    minute: minute43,
                                                    second: second43,
                                                    nanosecond: nanosecond43,
                                                } = time41;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour43)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute43)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second43)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond43);
                                            }
                                            Tsbound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date44,
                                                    time: time44,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year45,
                                                    month: month45,
                                                    day: day45,
                                                } = date44;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year45);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month45)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day45)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour46,
                                                    minute: minute46,
                                                    second: second46,
                                                    nanosecond: nanosecond46,
                                                } = time44;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour46)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute46)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second46)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond46);
                                            }
                                            Tsbound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end40 {
                                            Tsbound::Included(e) => {
                                                *base.add(28).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date47,
                                                    time: time47,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year48,
                                                    month: month48,
                                                    day: day48,
                                                } = date47;
                                                *base.add(32).cast::<i32>() = _rt::as_i32(year48);
                                                *base.add(36).cast::<u8>() = (_rt::as_i32(month48)) as u8;
                                                *base.add(37).cast::<u8>() = (_rt::as_i32(day48)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour49,
                                                    minute: minute49,
                                                    second: second49,
                                                    nanosecond: nanosecond49,
                                                } = time47;
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(hour49)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(minute49)) as u8;
                                                *base.add(42).cast::<u8>() = (_rt::as_i32(second49)) as u8;
                                                *base.add(44).cast::<i32>() = _rt::as_i32(nanosecond49);
                                            }
                                            Tsbound::Excluded(e) => {
                                                *base.add(28).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date50,
                                                    time: time50,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year51,
                                                    month: month51,
                                                    day: day51,
                                                } = date50;
                                                *base.add(32).cast::<i32>() = _rt::as_i32(year51);
                                                *base.add(36).cast::<u8>() = (_rt::as_i32(month51)) as u8;
                                                *base.add(37).cast::<u8>() = (_rt::as_i32(day51)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour52,
                                                    minute: minute52,
                                                    second: second52,
                                                    nanosecond: nanosecond52,
                                                } = time50;
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(hour52)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(minute52)) as u8;
                                                *base.add(42).cast::<u8>() = (_rt::as_i32(second52)) as u8;
                                                *base.add(44).cast::<i32>() = _rt::as_i32(nanosecond52);
                                            }
                                            Tsbound::Unbounded => {
                                                *base.add(28).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Tstzrange(e) => {
                                        *base.add(0).cast::<u8>() = (32i32) as u8;
                                        let Tstzrange { start: start53, end: end53 } = e;
                                        match start53 {
                                            Tstzbound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp54,
                                                    offset: offset54,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date55,
                                                    time: time55,
                                                } = timestamp54;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year56,
                                                    month: month56,
                                                    day: day56,
                                                } = date55;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year56);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month56)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day56)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour57,
                                                    minute: minute57,
                                                    second: second57,
                                                    nanosecond: nanosecond57,
                                                } = time55;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour57)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute57)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second57)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond57);
                                                *base.add(28).cast::<i32>() = _rt::as_i32(offset54);
                                            }
                                            Tstzbound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp58,
                                                    offset: offset58,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date59,
                                                    time: time59,
                                                } = timestamp58;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year60,
                                                    month: month60,
                                                    day: day60,
                                                } = date59;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year60);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month60)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day60)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour61,
                                                    minute: minute61,
                                                    second: second61,
                                                    nanosecond: nanosecond61,
                                                } = time59;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour61)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute61)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second61)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond61);
                                                *base.add(28).cast::<i32>() = _rt::as_i32(offset58);
                                            }
                                            Tstzbound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end53 {
                                            Tstzbound::Included(e) => {
                                                *base.add(32).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp62,
                                                    offset: offset62,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date63,
                                                    time: time63,
                                                } = timestamp62;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year64,
                                                    month: month64,
                                                    day: day64,
                                                } = date63;
                                                *base.add(36).cast::<i32>() = _rt::as_i32(year64);
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(month64)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(day64)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour65,
                                                    minute: minute65,
                                                    second: second65,
                                                    nanosecond: nanosecond65,
                                                } = time63;
                                                *base.add(44).cast::<u8>() = (_rt::as_i32(hour65)) as u8;
                                                *base.add(45).cast::<u8>() = (_rt::as_i32(minute65)) as u8;
                                                *base.add(46).cast::<u8>() = (_rt::as_i32(second65)) as u8;
                                                *base.add(48).cast::<i32>() = _rt::as_i32(nanosecond65);
                                                *base.add(52).cast::<i32>() = _rt::as_i32(offset62);
                                            }
                                            Tstzbound::Excluded(e) => {
                                                *base.add(32).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp66,
                                                    offset: offset66,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date67,
                                                    time: time67,
                                                } = timestamp66;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year68,
                                                    month: month68,
                                                    day: day68,
                                                } = date67;
                                                *base.add(36).cast::<i32>() = _rt::as_i32(year68);
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(month68)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(day68)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour69,
                                                    minute: minute69,
                                                    second: second69,
                                                    nanosecond: nanosecond69,
                                                } = time67;
                                                *base.add(44).cast::<u8>() = (_rt::as_i32(hour69)) as u8;
                                                *base.add(45).cast::<u8>() = (_rt::as_i32(minute69)) as u8;
                                                *base.add(46).cast::<u8>() = (_rt::as_i32(second69)) as u8;
                                                *base.add(48).cast::<i32>() = _rt::as_i32(nanosecond69);
                                                *base.add(52).cast::<i32>() = _rt::as_i32(offset66);
                                            }
                                            Tstzbound::Unbounded => {
                                                *base.add(32).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Daterange(e) => {
                                        *base.add(0).cast::<u8>() = (33i32) as u8;
                                        let Daterange { start: start70, end: end70 } = e;
                                        match start70 {
                                            Datebound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year71,
                                                    month: month71,
                                                    day: day71,
                                                } = e;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year71);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month71)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day71)) as u8;
                                            }
                                            Datebound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year72,
                                                    month: month72,
                                                    day: day72,
                                                } = e;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year72);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month72)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day72)) as u8;
                                            }
                                            Datebound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end70 {
                                            Datebound::Included(e) => {
                                                *base.add(20).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year73,
                                                    month: month73,
                                                    day: day73,
                                                } = e;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(year73);
                                                *base.add(28).cast::<u8>() = (_rt::as_i32(month73)) as u8;
                                                *base.add(29).cast::<u8>() = (_rt::as_i32(day73)) as u8;
                                            }
                                            Datebound::Excluded(e) => {
                                                *base.add(20).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year74,
                                                    month: month74,
                                                    day: day74,
                                                } = e;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(year74);
                                                *base.add(28).cast::<u8>() = (_rt::as_i32(month74)) as u8;
                                                *base.add(29).cast::<u8>() = (_rt::as_i32(day74)) as u8;
                                            }
                                            Datebound::Unbounded => {
                                                *base.add(20).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Money(e) => {
                                        *base.add(0).cast::<u8>() = (34i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::Oid(e) => {
                                        *base.add(0).cast::<u8>() = (35i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Enumeration(e) => {
                                        *base.add(0).cast::<u8>() = (36i32) as u8;
                                        let Enumeration { name: name75, value: value75 } = e;
                                        let vec76 = name75;
                                        let ptr76 = vec76.as_ptr().cast::<u8>();
                                        let len76 = vec76.len();
                                        *base.add(12).cast::<usize>() = len76;
                                        *base.add(8).cast::<*mut u8>() = ptr76.cast_mut();
                                        let vec77 = value75;
                                        let ptr77 = vec77.as_ptr().cast::<u8>();
                                        let len77 = vec77.len();
                                        *base.add(20).cast::<usize>() = len77;
                                        *base.add(16).cast::<*mut u8>() = ptr77.cast_mut();
                                    }
                                    DbValue::Composite(e) => {
                                        *base.add(0).cast::<u8>() = (37i32) as u8;
                                        let Composite { name: name78, values: values78 } = e;
                                        let vec79 = name78;
                                        let ptr79 = vec79.as_ptr().cast::<u8>();
                                        let len79 = vec79.len();
                                        *base.add(12).cast::<usize>() = len79;
                                        *base.add(8).cast::<*mut u8>() = ptr79.cast_mut();
                                        let vec80 = values78;
                                        let len80 = vec80.len();
                                        let layout80 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec80.len() * 4,
                                            4,
                                        );
                                        let result80 = if layout80.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout80).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout80);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec80.into_iter().enumerate() {
                                            let base = result80.add(i * 4);
                                            {
                                                *base.add(0).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                        }
                                        *base.add(20).cast::<usize>() = len80;
                                        *base.add(16).cast::<*mut u8>() = result80;
                                        cleanup_list.extend_from_slice(&[(result80, layout80)]);
                                    }
                                    DbValue::Domain(e) => {
                                        *base.add(0).cast::<u8>() = (38i32) as u8;
                                        let Domain { name: name81, value: value81 } = e;
                                        let vec82 = name81;
                                        let ptr82 = vec82.as_ptr().cast::<u8>();
                                        let len82 = vec82.len();
                                        *base.add(12).cast::<usize>() = len82;
                                        *base.add(8).cast::<*mut u8>() = ptr82.cast_mut();
                                        *base.add(16).cast::<i32>() = (value81).take_handle()
                                            as i32;
                                    }
                                    DbValue::Array(e) => {
                                        *base.add(0).cast::<u8>() = (39i32) as u8;
                                        let vec83 = e;
                                        let len83 = vec83.len();
                                        let layout83 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec83.len() * 4,
                                            4,
                                        );
                                        let result83 = if layout83.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout83).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout83);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec83.into_iter().enumerate() {
                                            let base = result83.add(i * 4);
                                            {
                                                *base.add(0).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len83;
                                        *base.add(8).cast::<*mut u8>() = result83;
                                        cleanup_list.extend_from_slice(&[(result83, layout83)]);
                                    }
                                    DbValue::Range(e) => {
                                        *base.add(0).cast::<u8>() = (40i32) as u8;
                                        let Range { name: name84, value: value84 } = e;
                                        let vec85 = name84;
                                        let ptr85 = vec85.as_ptr().cast::<u8>();
                                        let len85 = vec85.len();
                                        *base.add(12).cast::<usize>() = len85;
                                        *base.add(8).cast::<*mut u8>() = ptr85.cast_mut();
                                        let ValuesRange { start: start86, end: end86 } = value84;
                                        match start86 {
                                            ValueBound::Included(e) => {
                                                *base.add(16).cast::<u8>() = (0i32) as u8;
                                                *base.add(20).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Excluded(e) => {
                                                *base.add(16).cast::<u8>() = (1i32) as u8;
                                                *base.add(20).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Unbounded => {
                                                *base.add(16).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end86 {
                                            ValueBound::Included(e) => {
                                                *base.add(24).cast::<u8>() = (0i32) as u8;
                                                *base.add(28).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Excluded(e) => {
                                                *base.add(24).cast::<u8>() = (1i32) as u8;
                                                *base.add(28).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Unbounded => {
                                                *base.add(24).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Null => {
                                        *base.add(0).cast::<u8>() = (41i32) as u8;
                                    }
                                }
                            }
                        }
                        let ptr88 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rdbms/postgres@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-transaction.query-stream"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            result87,
                            len87,
                            ptr88,
                        );
                        let l89 = i32::from(*ptr88.add(0).cast::<u8>());
                        if layout87.size() != 0 {
                            _rt::alloc::dealloc(result87.cast(), layout87);
                        }
                        for (ptr, layout) in cleanup_list {
                            if layout.size() != 0 {
                                _rt::alloc::dealloc(ptr.cast(), layout);
                            }
                        }
                        match l89 {
                            0 => {
                                let e = {
                                    let l90 = *ptr88.add(4).cast::<i32>();
                                    DbResultStream::from_handle(l90 as u32)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l91 = i32::from(*ptr88.add(4).cast::<u8>());
                                    let v107 = match l91 {
                                        0 => {
                                            let e107 = {
                                                let l92 = *ptr88.add(8).cast::<*mut u8>();
                                                let l93 = *ptr88.add(12).cast::<usize>();
                                                let len94 = l93;
                                                let bytes94 = _rt::Vec::from_raw_parts(
                                                    l92.cast(),
                                                    len94,
                                                    len94,
                                                );
                                                _rt::string_lift(bytes94)
                                            };
                                            Error::ConnectionFailure(e107)
                                        }
                                        1 => {
                                            let e107 = {
                                                let l95 = *ptr88.add(8).cast::<*mut u8>();
                                                let l96 = *ptr88.add(12).cast::<usize>();
                                                let len97 = l96;
                                                let bytes97 = _rt::Vec::from_raw_parts(
                                                    l95.cast(),
                                                    len97,
                                                    len97,
                                                );
                                                _rt::string_lift(bytes97)
                                            };
                                            Error::QueryParameterFailure(e107)
                                        }
                                        2 => {
                                            let e107 = {
                                                let l98 = *ptr88.add(8).cast::<*mut u8>();
                                                let l99 = *ptr88.add(12).cast::<usize>();
                                                let len100 = l99;
                                                let bytes100 = _rt::Vec::from_raw_parts(
                                                    l98.cast(),
                                                    len100,
                                                    len100,
                                                );
                                                _rt::string_lift(bytes100)
                                            };
                                            Error::QueryExecutionFailure(e107)
                                        }
                                        3 => {
                                            let e107 = {
                                                let l101 = *ptr88.add(8).cast::<*mut u8>();
                                                let l102 = *ptr88.add(12).cast::<usize>();
                                                let len103 = l102;
                                                let bytes103 = _rt::Vec::from_raw_parts(
                                                    l101.cast(),
                                                    len103,
                                                    len103,
                                                );
                                                _rt::string_lift(bytes103)
                                            };
                                            Error::QueryResponseFailure(e107)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 4, "invalid enum discriminant");
                                            let e107 = {
                                                let l104 = *ptr88.add(8).cast::<*mut u8>();
                                                let l105 = *ptr88.add(12).cast::<usize>();
                                                let len106 = l105;
                                                let bytes106 = _rt::Vec::from_raw_parts(
                                                    l104.cast(),
                                                    len106,
                                                    len106,
                                                );
                                                _rt::string_lift(bytes106)
                                            };
                                            Error::Other(e107)
                                        }
                                    };
                                    v107
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl DbTransaction {
                #[allow(unused_unsafe, clippy::all)]
                pub fn execute(
                    &self,
                    statement: &str,
                    params: _rt::Vec<DbValue>,
                ) -> Result<u64, Error> {
                    unsafe {
                        let mut cleanup_list = _rt::Vec::new();
                        #[repr(align(8))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 24]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 24],
                        );
                        let vec0 = statement;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let vec87 = &params;
                        let len87 = vec87.len();
                        let layout87 = _rt::alloc::Layout::from_size_align_unchecked(
                            vec87.len() * 56,
                            8,
                        );
                        let result87 = if layout87.size() != 0 {
                            let ptr = _rt::alloc::alloc(layout87).cast::<u8>();
                            if ptr.is_null() {
                                _rt::alloc::handle_alloc_error(layout87);
                            }
                            ptr
                        } else {
                            ::core::ptr::null_mut()
                        };
                        for (i, e) in vec87.into_iter().enumerate() {
                            let base = result87.add(i * 56);
                            {
                                match e {
                                    DbValue::Character(e) => {
                                        *base.add(0).cast::<u8>() = (0i32) as u8;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                    }
                                    DbValue::Int2(e) => {
                                        *base.add(0).cast::<u8>() = (1i32) as u8;
                                        *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                    }
                                    DbValue::Int4(e) => {
                                        *base.add(0).cast::<u8>() = (2i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Int8(e) => {
                                        *base.add(0).cast::<u8>() = (3i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::Float4(e) => {
                                        *base.add(0).cast::<u8>() = (4i32) as u8;
                                        *base.add(8).cast::<f32>() = _rt::as_f32(e);
                                    }
                                    DbValue::Float8(e) => {
                                        *base.add(0).cast::<u8>() = (5i32) as u8;
                                        *base.add(8).cast::<f64>() = _rt::as_f64(e);
                                    }
                                    DbValue::Numeric(e) => {
                                        *base.add(0).cast::<u8>() = (6i32) as u8;
                                        let vec1 = e;
                                        let ptr1 = vec1.as_ptr().cast::<u8>();
                                        let len1 = vec1.len();
                                        *base.add(12).cast::<usize>() = len1;
                                        *base.add(8).cast::<*mut u8>() = ptr1.cast_mut();
                                    }
                                    DbValue::Boolean(e) => {
                                        *base.add(0).cast::<u8>() = (7i32) as u8;
                                        *base.add(8).cast::<u8>() = (match e {
                                            true => 1,
                                            false => 0,
                                        }) as u8;
                                    }
                                    DbValue::Text(e) => {
                                        *base.add(0).cast::<u8>() = (8i32) as u8;
                                        let vec2 = e;
                                        let ptr2 = vec2.as_ptr().cast::<u8>();
                                        let len2 = vec2.len();
                                        *base.add(12).cast::<usize>() = len2;
                                        *base.add(8).cast::<*mut u8>() = ptr2.cast_mut();
                                    }
                                    DbValue::Varchar(e) => {
                                        *base.add(0).cast::<u8>() = (9i32) as u8;
                                        let vec3 = e;
                                        let ptr3 = vec3.as_ptr().cast::<u8>();
                                        let len3 = vec3.len();
                                        *base.add(12).cast::<usize>() = len3;
                                        *base.add(8).cast::<*mut u8>() = ptr3.cast_mut();
                                    }
                                    DbValue::Bpchar(e) => {
                                        *base.add(0).cast::<u8>() = (10i32) as u8;
                                        let vec4 = e;
                                        let ptr4 = vec4.as_ptr().cast::<u8>();
                                        let len4 = vec4.len();
                                        *base.add(12).cast::<usize>() = len4;
                                        *base.add(8).cast::<*mut u8>() = ptr4.cast_mut();
                                    }
                                    DbValue::Timestamp(e) => {
                                        *base.add(0).cast::<u8>() = (11i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date5,
                                            time: time5,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year6,
                                            month: month6,
                                            day: day6,
                                        } = date5;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year6);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month6)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day6)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour7,
                                            minute: minute7,
                                            second: second7,
                                            nanosecond: nanosecond7,
                                        } = time5;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour7)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute7)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second7)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond7);
                                    }
                                    DbValue::Timestamptz(e) => {
                                        *base.add(0).cast::<u8>() = (12i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timestamptz {
                                            timestamp: timestamp8,
                                            offset: offset8,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Timestamp {
                                            date: date9,
                                            time: time9,
                                        } = timestamp8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year10,
                                            month: month10,
                                            day: day10,
                                        } = date9;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year10);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month10)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day10)) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour11,
                                            minute: minute11,
                                            second: second11,
                                            nanosecond: nanosecond11,
                                        } = time9;
                                        *base.add(16).cast::<u8>() = (_rt::as_i32(hour11)) as u8;
                                        *base.add(17).cast::<u8>() = (_rt::as_i32(minute11)) as u8;
                                        *base.add(18).cast::<u8>() = (_rt::as_i32(second11)) as u8;
                                        *base.add(20).cast::<i32>() = _rt::as_i32(nanosecond11);
                                        *base.add(24).cast::<i32>() = _rt::as_i32(offset8);
                                    }
                                    DbValue::Date(e) => {
                                        *base.add(0).cast::<u8>() = (13i32) as u8;
                                        let super::super::super::golem::rdbms::types::Date {
                                            year: year12,
                                            month: month12,
                                            day: day12,
                                        } = e;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(year12);
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(month12)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(day12)) as u8;
                                    }
                                    DbValue::Time(e) => {
                                        *base.add(0).cast::<u8>() = (14i32) as u8;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour13,
                                            minute: minute13,
                                            second: second13,
                                            nanosecond: nanosecond13,
                                        } = e;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(hour13)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(minute13)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(second13)) as u8;
                                        *base.add(12).cast::<i32>() = _rt::as_i32(nanosecond13);
                                    }
                                    DbValue::Timetz(e) => {
                                        *base.add(0).cast::<u8>() = (15i32) as u8;
                                        let super::super::super::golem::rdbms::types::Timetz {
                                            time: time14,
                                            offset: offset14,
                                        } = e;
                                        let super::super::super::golem::rdbms::types::Time {
                                            hour: hour15,
                                            minute: minute15,
                                            second: second15,
                                            nanosecond: nanosecond15,
                                        } = time14;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(hour15)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(minute15)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(second15)) as u8;
                                        *base.add(12).cast::<i32>() = _rt::as_i32(nanosecond15);
                                        *base.add(16).cast::<i32>() = _rt::as_i32(offset14);
                                    }
                                    DbValue::Interval(e) => {
                                        *base.add(0).cast::<u8>() = (16i32) as u8;
                                        let Interval {
                                            months: months16,
                                            days: days16,
                                            microseconds: microseconds16,
                                        } = e;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(months16);
                                        *base.add(12).cast::<i32>() = _rt::as_i32(days16);
                                        *base.add(16).cast::<i64>() = _rt::as_i64(microseconds16);
                                    }
                                    DbValue::Bytea(e) => {
                                        *base.add(0).cast::<u8>() = (17i32) as u8;
                                        let vec17 = e;
                                        let ptr17 = vec17.as_ptr().cast::<u8>();
                                        let len17 = vec17.len();
                                        *base.add(12).cast::<usize>() = len17;
                                        *base.add(8).cast::<*mut u8>() = ptr17.cast_mut();
                                    }
                                    DbValue::Json(e) => {
                                        *base.add(0).cast::<u8>() = (18i32) as u8;
                                        let vec18 = e;
                                        let ptr18 = vec18.as_ptr().cast::<u8>();
                                        let len18 = vec18.len();
                                        *base.add(12).cast::<usize>() = len18;
                                        *base.add(8).cast::<*mut u8>() = ptr18.cast_mut();
                                    }
                                    DbValue::Jsonb(e) => {
                                        *base.add(0).cast::<u8>() = (19i32) as u8;
                                        let vec19 = e;
                                        let ptr19 = vec19.as_ptr().cast::<u8>();
                                        let len19 = vec19.len();
                                        *base.add(12).cast::<usize>() = len19;
                                        *base.add(8).cast::<*mut u8>() = ptr19.cast_mut();
                                    }
                                    DbValue::Jsonpath(e) => {
                                        *base.add(0).cast::<u8>() = (20i32) as u8;
                                        let vec20 = e;
                                        let ptr20 = vec20.as_ptr().cast::<u8>();
                                        let len20 = vec20.len();
                                        *base.add(12).cast::<usize>() = len20;
                                        *base.add(8).cast::<*mut u8>() = ptr20.cast_mut();
                                    }
                                    DbValue::Xml(e) => {
                                        *base.add(0).cast::<u8>() = (21i32) as u8;
                                        let vec21 = e;
                                        let ptr21 = vec21.as_ptr().cast::<u8>();
                                        let len21 = vec21.len();
                                        *base.add(12).cast::<usize>() = len21;
                                        *base.add(8).cast::<*mut u8>() = ptr21.cast_mut();
                                    }
                                    DbValue::Uuid(e) => {
                                        *base.add(0).cast::<u8>() = (22i32) as u8;
                                        let super::super::super::golem::rdbms::types::Uuid {
                                            high_bits: high_bits22,
                                            low_bits: low_bits22,
                                        } = e;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(high_bits22);
                                        *base.add(16).cast::<i64>() = _rt::as_i64(low_bits22);
                                    }
                                    DbValue::Inet(e) => {
                                        *base.add(0).cast::<u8>() = (23i32) as u8;
                                        use super::super::super::golem::rdbms::types::IpAddress as V25;
                                        match e {
                                            V25::Ipv4(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let (t23_0, t23_1, t23_2, t23_3) = e;
                                                *base.add(10).cast::<u8>() = (_rt::as_i32(t23_0)) as u8;
                                                *base.add(11).cast::<u8>() = (_rt::as_i32(t23_1)) as u8;
                                                *base.add(12).cast::<u8>() = (_rt::as_i32(t23_2)) as u8;
                                                *base.add(13).cast::<u8>() = (_rt::as_i32(t23_3)) as u8;
                                            }
                                            V25::Ipv6(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let (
                                                    t24_0,
                                                    t24_1,
                                                    t24_2,
                                                    t24_3,
                                                    t24_4,
                                                    t24_5,
                                                    t24_6,
                                                    t24_7,
                                                ) = e;
                                                *base.add(10).cast::<u16>() = (_rt::as_i32(t24_0)) as u16;
                                                *base.add(12).cast::<u16>() = (_rt::as_i32(t24_1)) as u16;
                                                *base.add(14).cast::<u16>() = (_rt::as_i32(t24_2)) as u16;
                                                *base.add(16).cast::<u16>() = (_rt::as_i32(t24_3)) as u16;
                                                *base.add(18).cast::<u16>() = (_rt::as_i32(t24_4)) as u16;
                                                *base.add(20).cast::<u16>() = (_rt::as_i32(t24_5)) as u16;
                                                *base.add(22).cast::<u16>() = (_rt::as_i32(t24_6)) as u16;
                                                *base.add(24).cast::<u16>() = (_rt::as_i32(t24_7)) as u16;
                                            }
                                        }
                                    }
                                    DbValue::Cidr(e) => {
                                        *base.add(0).cast::<u8>() = (24i32) as u8;
                                        use super::super::super::golem::rdbms::types::IpAddress as V28;
                                        match e {
                                            V28::Ipv4(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let (t26_0, t26_1, t26_2, t26_3) = e;
                                                *base.add(10).cast::<u8>() = (_rt::as_i32(t26_0)) as u8;
                                                *base.add(11).cast::<u8>() = (_rt::as_i32(t26_1)) as u8;
                                                *base.add(12).cast::<u8>() = (_rt::as_i32(t26_2)) as u8;
                                                *base.add(13).cast::<u8>() = (_rt::as_i32(t26_3)) as u8;
                                            }
                                            V28::Ipv6(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let (
                                                    t27_0,
                                                    t27_1,
                                                    t27_2,
                                                    t27_3,
                                                    t27_4,
                                                    t27_5,
                                                    t27_6,
                                                    t27_7,
                                                ) = e;
                                                *base.add(10).cast::<u16>() = (_rt::as_i32(t27_0)) as u16;
                                                *base.add(12).cast::<u16>() = (_rt::as_i32(t27_1)) as u16;
                                                *base.add(14).cast::<u16>() = (_rt::as_i32(t27_2)) as u16;
                                                *base.add(16).cast::<u16>() = (_rt::as_i32(t27_3)) as u16;
                                                *base.add(18).cast::<u16>() = (_rt::as_i32(t27_4)) as u16;
                                                *base.add(20).cast::<u16>() = (_rt::as_i32(t27_5)) as u16;
                                                *base.add(22).cast::<u16>() = (_rt::as_i32(t27_6)) as u16;
                                                *base.add(24).cast::<u16>() = (_rt::as_i32(t27_7)) as u16;
                                            }
                                        }
                                    }
                                    DbValue::Macaddr(e) => {
                                        *base.add(0).cast::<u8>() = (25i32) as u8;
                                        let super::super::super::golem::rdbms::types::MacAddress {
                                            octets: octets29,
                                        } = e;
                                        let (t30_0, t30_1, t30_2, t30_3, t30_4, t30_5) = octets29;
                                        *base.add(8).cast::<u8>() = (_rt::as_i32(t30_0)) as u8;
                                        *base.add(9).cast::<u8>() = (_rt::as_i32(t30_1)) as u8;
                                        *base.add(10).cast::<u8>() = (_rt::as_i32(t30_2)) as u8;
                                        *base.add(11).cast::<u8>() = (_rt::as_i32(t30_3)) as u8;
                                        *base.add(12).cast::<u8>() = (_rt::as_i32(t30_4)) as u8;
                                        *base.add(13).cast::<u8>() = (_rt::as_i32(t30_5)) as u8;
                                    }
                                    DbValue::Bit(e) => {
                                        *base.add(0).cast::<u8>() = (26i32) as u8;
                                        let vec31 = e;
                                        let len31 = vec31.len();
                                        let layout31 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec31.len() * 1,
                                            1,
                                        );
                                        let result31 = if layout31.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout31).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout31);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec31.into_iter().enumerate() {
                                            let base = result31.add(i * 1);
                                            {
                                                *base.add(0).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len31;
                                        *base.add(8).cast::<*mut u8>() = result31;
                                        cleanup_list.extend_from_slice(&[(result31, layout31)]);
                                    }
                                    DbValue::Varbit(e) => {
                                        *base.add(0).cast::<u8>() = (27i32) as u8;
                                        let vec32 = e;
                                        let len32 = vec32.len();
                                        let layout32 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec32.len() * 1,
                                            1,
                                        );
                                        let result32 = if layout32.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout32).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout32);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec32.into_iter().enumerate() {
                                            let base = result32.add(i * 1);
                                            {
                                                *base.add(0).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len32;
                                        *base.add(8).cast::<*mut u8>() = result32;
                                        cleanup_list.extend_from_slice(&[(result32, layout32)]);
                                    }
                                    DbValue::Int4range(e) => {
                                        *base.add(0).cast::<u8>() = (28i32) as u8;
                                        let Int4range { start: start33, end: end33 } = e;
                                        match start33 {
                                            Int4bound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end33 {
                                            Int4bound::Included(e) => {
                                                *base.add(16).cast::<u8>() = (0i32) as u8;
                                                *base.add(20).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Excluded(e) => {
                                                *base.add(16).cast::<u8>() = (1i32) as u8;
                                                *base.add(20).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            Int4bound::Unbounded => {
                                                *base.add(16).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Int8range(e) => {
                                        *base.add(0).cast::<u8>() = (29i32) as u8;
                                        let Int8range { start: start34, end: end34 } = e;
                                        match start34 {
                                            Int8bound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                *base.add(16).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                *base.add(16).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end34 {
                                            Int8bound::Included(e) => {
                                                *base.add(24).cast::<u8>() = (0i32) as u8;
                                                *base.add(32).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Excluded(e) => {
                                                *base.add(24).cast::<u8>() = (1i32) as u8;
                                                *base.add(32).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            Int8bound::Unbounded => {
                                                *base.add(24).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Numrange(e) => {
                                        *base.add(0).cast::<u8>() = (30i32) as u8;
                                        let Numrange { start: start35, end: end35 } = e;
                                        match start35 {
                                            Numbound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let vec36 = e;
                                                let ptr36 = vec36.as_ptr().cast::<u8>();
                                                let len36 = vec36.len();
                                                *base.add(16).cast::<usize>() = len36;
                                                *base.add(12).cast::<*mut u8>() = ptr36.cast_mut();
                                            }
                                            Numbound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let vec37 = e;
                                                let ptr37 = vec37.as_ptr().cast::<u8>();
                                                let len37 = vec37.len();
                                                *base.add(16).cast::<usize>() = len37;
                                                *base.add(12).cast::<*mut u8>() = ptr37.cast_mut();
                                            }
                                            Numbound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end35 {
                                            Numbound::Included(e) => {
                                                *base.add(20).cast::<u8>() = (0i32) as u8;
                                                let vec38 = e;
                                                let ptr38 = vec38.as_ptr().cast::<u8>();
                                                let len38 = vec38.len();
                                                *base.add(28).cast::<usize>() = len38;
                                                *base.add(24).cast::<*mut u8>() = ptr38.cast_mut();
                                            }
                                            Numbound::Excluded(e) => {
                                                *base.add(20).cast::<u8>() = (1i32) as u8;
                                                let vec39 = e;
                                                let ptr39 = vec39.as_ptr().cast::<u8>();
                                                let len39 = vec39.len();
                                                *base.add(28).cast::<usize>() = len39;
                                                *base.add(24).cast::<*mut u8>() = ptr39.cast_mut();
                                            }
                                            Numbound::Unbounded => {
                                                *base.add(20).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Tsrange(e) => {
                                        *base.add(0).cast::<u8>() = (31i32) as u8;
                                        let Tsrange { start: start40, end: end40 } = e;
                                        match start40 {
                                            Tsbound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date41,
                                                    time: time41,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year42,
                                                    month: month42,
                                                    day: day42,
                                                } = date41;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year42);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month42)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day42)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour43,
                                                    minute: minute43,
                                                    second: second43,
                                                    nanosecond: nanosecond43,
                                                } = time41;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour43)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute43)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second43)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond43);
                                            }
                                            Tsbound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date44,
                                                    time: time44,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year45,
                                                    month: month45,
                                                    day: day45,
                                                } = date44;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year45);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month45)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day45)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour46,
                                                    minute: minute46,
                                                    second: second46,
                                                    nanosecond: nanosecond46,
                                                } = time44;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour46)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute46)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second46)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond46);
                                            }
                                            Tsbound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end40 {
                                            Tsbound::Included(e) => {
                                                *base.add(28).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date47,
                                                    time: time47,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year48,
                                                    month: month48,
                                                    day: day48,
                                                } = date47;
                                                *base.add(32).cast::<i32>() = _rt::as_i32(year48);
                                                *base.add(36).cast::<u8>() = (_rt::as_i32(month48)) as u8;
                                                *base.add(37).cast::<u8>() = (_rt::as_i32(day48)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour49,
                                                    minute: minute49,
                                                    second: second49,
                                                    nanosecond: nanosecond49,
                                                } = time47;
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(hour49)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(minute49)) as u8;
                                                *base.add(42).cast::<u8>() = (_rt::as_i32(second49)) as u8;
                                                *base.add(44).cast::<i32>() = _rt::as_i32(nanosecond49);
                                            }
                                            Tsbound::Excluded(e) => {
                                                *base.add(28).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date50,
                                                    time: time50,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year51,
                                                    month: month51,
                                                    day: day51,
                                                } = date50;
                                                *base.add(32).cast::<i32>() = _rt::as_i32(year51);
                                                *base.add(36).cast::<u8>() = (_rt::as_i32(month51)) as u8;
                                                *base.add(37).cast::<u8>() = (_rt::as_i32(day51)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour52,
                                                    minute: minute52,
                                                    second: second52,
                                                    nanosecond: nanosecond52,
                                                } = time50;
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(hour52)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(minute52)) as u8;
                                                *base.add(42).cast::<u8>() = (_rt::as_i32(second52)) as u8;
                                                *base.add(44).cast::<i32>() = _rt::as_i32(nanosecond52);
                                            }
                                            Tsbound::Unbounded => {
                                                *base.add(28).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Tstzrange(e) => {
                                        *base.add(0).cast::<u8>() = (32i32) as u8;
                                        let Tstzrange { start: start53, end: end53 } = e;
                                        match start53 {
                                            Tstzbound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp54,
                                                    offset: offset54,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date55,
                                                    time: time55,
                                                } = timestamp54;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year56,
                                                    month: month56,
                                                    day: day56,
                                                } = date55;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year56);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month56)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day56)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour57,
                                                    minute: minute57,
                                                    second: second57,
                                                    nanosecond: nanosecond57,
                                                } = time55;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour57)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute57)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second57)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond57);
                                                *base.add(28).cast::<i32>() = _rt::as_i32(offset54);
                                            }
                                            Tstzbound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp58,
                                                    offset: offset58,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date59,
                                                    time: time59,
                                                } = timestamp58;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year60,
                                                    month: month60,
                                                    day: day60,
                                                } = date59;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year60);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month60)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day60)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour61,
                                                    minute: minute61,
                                                    second: second61,
                                                    nanosecond: nanosecond61,
                                                } = time59;
                                                *base.add(20).cast::<u8>() = (_rt::as_i32(hour61)) as u8;
                                                *base.add(21).cast::<u8>() = (_rt::as_i32(minute61)) as u8;
                                                *base.add(22).cast::<u8>() = (_rt::as_i32(second61)) as u8;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(nanosecond61);
                                                *base.add(28).cast::<i32>() = _rt::as_i32(offset58);
                                            }
                                            Tstzbound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end53 {
                                            Tstzbound::Included(e) => {
                                                *base.add(32).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp62,
                                                    offset: offset62,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date63,
                                                    time: time63,
                                                } = timestamp62;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year64,
                                                    month: month64,
                                                    day: day64,
                                                } = date63;
                                                *base.add(36).cast::<i32>() = _rt::as_i32(year64);
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(month64)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(day64)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour65,
                                                    minute: minute65,
                                                    second: second65,
                                                    nanosecond: nanosecond65,
                                                } = time63;
                                                *base.add(44).cast::<u8>() = (_rt::as_i32(hour65)) as u8;
                                                *base.add(45).cast::<u8>() = (_rt::as_i32(minute65)) as u8;
                                                *base.add(46).cast::<u8>() = (_rt::as_i32(second65)) as u8;
                                                *base.add(48).cast::<i32>() = _rt::as_i32(nanosecond65);
                                                *base.add(52).cast::<i32>() = _rt::as_i32(offset62);
                                            }
                                            Tstzbound::Excluded(e) => {
                                                *base.add(32).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Timestamptz {
                                                    timestamp: timestamp66,
                                                    offset: offset66,
                                                } = e;
                                                let super::super::super::golem::rdbms::types::Timestamp {
                                                    date: date67,
                                                    time: time67,
                                                } = timestamp66;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year68,
                                                    month: month68,
                                                    day: day68,
                                                } = date67;
                                                *base.add(36).cast::<i32>() = _rt::as_i32(year68);
                                                *base.add(40).cast::<u8>() = (_rt::as_i32(month68)) as u8;
                                                *base.add(41).cast::<u8>() = (_rt::as_i32(day68)) as u8;
                                                let super::super::super::golem::rdbms::types::Time {
                                                    hour: hour69,
                                                    minute: minute69,
                                                    second: second69,
                                                    nanosecond: nanosecond69,
                                                } = time67;
                                                *base.add(44).cast::<u8>() = (_rt::as_i32(hour69)) as u8;
                                                *base.add(45).cast::<u8>() = (_rt::as_i32(minute69)) as u8;
                                                *base.add(46).cast::<u8>() = (_rt::as_i32(second69)) as u8;
                                                *base.add(48).cast::<i32>() = _rt::as_i32(nanosecond69);
                                                *base.add(52).cast::<i32>() = _rt::as_i32(offset66);
                                            }
                                            Tstzbound::Unbounded => {
                                                *base.add(32).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Daterange(e) => {
                                        *base.add(0).cast::<u8>() = (33i32) as u8;
                                        let Daterange { start: start70, end: end70 } = e;
                                        match start70 {
                                            Datebound::Included(e) => {
                                                *base.add(8).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year71,
                                                    month: month71,
                                                    day: day71,
                                                } = e;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year71);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month71)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day71)) as u8;
                                            }
                                            Datebound::Excluded(e) => {
                                                *base.add(8).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year72,
                                                    month: month72,
                                                    day: day72,
                                                } = e;
                                                *base.add(12).cast::<i32>() = _rt::as_i32(year72);
                                                *base.add(16).cast::<u8>() = (_rt::as_i32(month72)) as u8;
                                                *base.add(17).cast::<u8>() = (_rt::as_i32(day72)) as u8;
                                            }
                                            Datebound::Unbounded => {
                                                *base.add(8).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end70 {
                                            Datebound::Included(e) => {
                                                *base.add(20).cast::<u8>() = (0i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year73,
                                                    month: month73,
                                                    day: day73,
                                                } = e;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(year73);
                                                *base.add(28).cast::<u8>() = (_rt::as_i32(month73)) as u8;
                                                *base.add(29).cast::<u8>() = (_rt::as_i32(day73)) as u8;
                                            }
                                            Datebound::Excluded(e) => {
                                                *base.add(20).cast::<u8>() = (1i32) as u8;
                                                let super::super::super::golem::rdbms::types::Date {
                                                    year: year74,
                                                    month: month74,
                                                    day: day74,
                                                } = e;
                                                *base.add(24).cast::<i32>() = _rt::as_i32(year74);
                                                *base.add(28).cast::<u8>() = (_rt::as_i32(month74)) as u8;
                                                *base.add(29).cast::<u8>() = (_rt::as_i32(day74)) as u8;
                                            }
                                            Datebound::Unbounded => {
                                                *base.add(20).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Money(e) => {
                                        *base.add(0).cast::<u8>() = (34i32) as u8;
                                        *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                    }
                                    DbValue::Oid(e) => {
                                        *base.add(0).cast::<u8>() = (35i32) as u8;
                                        *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                    }
                                    DbValue::Enumeration(e) => {
                                        *base.add(0).cast::<u8>() = (36i32) as u8;
                                        let Enumeration { name: name75, value: value75 } = e;
                                        let vec76 = name75;
                                        let ptr76 = vec76.as_ptr().cast::<u8>();
                                        let len76 = vec76.len();
                                        *base.add(12).cast::<usize>() = len76;
                                        *base.add(8).cast::<*mut u8>() = ptr76.cast_mut();
                                        let vec77 = value75;
                                        let ptr77 = vec77.as_ptr().cast::<u8>();
                                        let len77 = vec77.len();
                                        *base.add(20).cast::<usize>() = len77;
                                        *base.add(16).cast::<*mut u8>() = ptr77.cast_mut();
                                    }
                                    DbValue::Composite(e) => {
                                        *base.add(0).cast::<u8>() = (37i32) as u8;
                                        let Composite { name: name78, values: values78 } = e;
                                        let vec79 = name78;
                                        let ptr79 = vec79.as_ptr().cast::<u8>();
                                        let len79 = vec79.len();
                                        *base.add(12).cast::<usize>() = len79;
                                        *base.add(8).cast::<*mut u8>() = ptr79.cast_mut();
                                        let vec80 = values78;
                                        let len80 = vec80.len();
                                        let layout80 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec80.len() * 4,
                                            4,
                                        );
                                        let result80 = if layout80.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout80).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout80);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec80.into_iter().enumerate() {
                                            let base = result80.add(i * 4);
                                            {
                                                *base.add(0).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                        }
                                        *base.add(20).cast::<usize>() = len80;
                                        *base.add(16).cast::<*mut u8>() = result80;
                                        cleanup_list.extend_from_slice(&[(result80, layout80)]);
                                    }
                                    DbValue::Domain(e) => {
                                        *base.add(0).cast::<u8>() = (38i32) as u8;
                                        let Domain { name: name81, value: value81 } = e;
                                        let vec82 = name81;
                                        let ptr82 = vec82.as_ptr().cast::<u8>();
                                        let len82 = vec82.len();
                                        *base.add(12).cast::<usize>() = len82;
                                        *base.add(8).cast::<*mut u8>() = ptr82.cast_mut();
                                        *base.add(16).cast::<i32>() = (value81).take_handle()
                                            as i32;
                                    }
                                    DbValue::Array(e) => {
                                        *base.add(0).cast::<u8>() = (39i32) as u8;
                                        let vec83 = e;
                                        let len83 = vec83.len();
                                        let layout83 = _rt::alloc::Layout::from_size_align_unchecked(
                                            vec83.len() * 4,
                                            4,
                                        );
                                        let result83 = if layout83.size() != 0 {
                                            let ptr = _rt::alloc::alloc(layout83).cast::<u8>();
                                            if ptr.is_null() {
                                                _rt::alloc::handle_alloc_error(layout83);
                                            }
                                            ptr
                                        } else {
                                            ::core::ptr::null_mut()
                                        };
                                        for (i, e) in vec83.into_iter().enumerate() {
                                            let base = result83.add(i * 4);
                                            {
                                                *base.add(0).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                        }
                                        *base.add(12).cast::<usize>() = len83;
                                        *base.add(8).cast::<*mut u8>() = result83;
                                        cleanup_list.extend_from_slice(&[(result83, layout83)]);
                                    }
                                    DbValue::Range(e) => {
                                        *base.add(0).cast::<u8>() = (40i32) as u8;
                                        let Range { name: name84, value: value84 } = e;
                                        let vec85 = name84;
                                        let ptr85 = vec85.as_ptr().cast::<u8>();
                                        let len85 = vec85.len();
                                        *base.add(12).cast::<usize>() = len85;
                                        *base.add(8).cast::<*mut u8>() = ptr85.cast_mut();
                                        let ValuesRange { start: start86, end: end86 } = value84;
                                        match start86 {
                                            ValueBound::Included(e) => {
                                                *base.add(16).cast::<u8>() = (0i32) as u8;
                                                *base.add(20).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Excluded(e) => {
                                                *base.add(16).cast::<u8>() = (1i32) as u8;
                                                *base.add(20).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Unbounded => {
                                                *base.add(16).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                        match end86 {
                                            ValueBound::Included(e) => {
                                                *base.add(24).cast::<u8>() = (0i32) as u8;
                                                *base.add(28).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Excluded(e) => {
                                                *base.add(24).cast::<u8>() = (1i32) as u8;
                                                *base.add(28).cast::<i32>() = (e).take_handle() as i32;
                                            }
                                            ValueBound::Unbounded => {
                                                *base.add(24).cast::<u8>() = (2i32) as u8;
                                            }
                                        }
                                    }
                                    DbValue::Null => {
                                        *base.add(0).cast::<u8>() = (41i32) as u8;
                                    }
                                }
                            }
                        }
                        let ptr88 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rdbms/postgres@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-transaction.execute"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            result87,
                            len87,
                            ptr88,
                        );
                        let l89 = i32::from(*ptr88.add(0).cast::<u8>());
                        if layout87.size() != 0 {
                            _rt::alloc::dealloc(result87.cast(), layout87);
                        }
                        for (ptr, layout) in cleanup_list {
                            if layout.size() != 0 {
                                _rt::alloc::dealloc(ptr.cast(), layout);
                            }
                        }
                        match l89 {
                            0 => {
                                let e = {
                                    let l90 = *ptr88.add(8).cast::<i64>();
                                    l90 as u64
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l91 = i32::from(*ptr88.add(8).cast::<u8>());
                                    let v107 = match l91 {
                                        0 => {
                                            let e107 = {
                                                let l92 = *ptr88.add(12).cast::<*mut u8>();
                                                let l93 = *ptr88.add(16).cast::<usize>();
                                                let len94 = l93;
                                                let bytes94 = _rt::Vec::from_raw_parts(
                                                    l92.cast(),
                                                    len94,
                                                    len94,
                                                );
                                                _rt::string_lift(bytes94)
                                            };
                                            Error::ConnectionFailure(e107)
                                        }
                                        1 => {
                                            let e107 = {
                                                let l95 = *ptr88.add(12).cast::<*mut u8>();
                                                let l96 = *ptr88.add(16).cast::<usize>();
                                                let len97 = l96;
                                                let bytes97 = _rt::Vec::from_raw_parts(
                                                    l95.cast(),
                                                    len97,
                                                    len97,
                                                );
                                                _rt::string_lift(bytes97)
                                            };
                                            Error::QueryParameterFailure(e107)
                                        }
                                        2 => {
                                            let e107 = {
                                                let l98 = *ptr88.add(12).cast::<*mut u8>();
                                                let l99 = *ptr88.add(16).cast::<usize>();
                                                let len100 = l99;
                                                let bytes100 = _rt::Vec::from_raw_parts(
                                                    l98.cast(),
                                                    len100,
                                                    len100,
                                                );
                                                _rt::string_lift(bytes100)
                                            };
                                            Error::QueryExecutionFailure(e107)
                                        }
                                        3 => {
                                            let e107 = {
                                                let l101 = *ptr88.add(12).cast::<*mut u8>();
                                                let l102 = *ptr88.add(16).cast::<usize>();
                                                let len103 = l102;
                                                let bytes103 = _rt::Vec::from_raw_parts(
                                                    l101.cast(),
                                                    len103,
                                                    len103,
                                                );
                                                _rt::string_lift(bytes103)
                                            };
                                            Error::QueryResponseFailure(e107)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 4, "invalid enum discriminant");
                                            let e107 = {
                                                let l104 = *ptr88.add(12).cast::<*mut u8>();
                                                let l105 = *ptr88.add(16).cast::<usize>();
                                                let len106 = l105;
                                                let bytes106 = _rt::Vec::from_raw_parts(
                                                    l104.cast(),
                                                    len106,
                                                    len106,
                                                );
                                                _rt::string_lift(bytes106)
                                            };
                                            Error::Other(e107)
                                        }
                                    };
                                    v107
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl DbTransaction {
                #[allow(unused_unsafe, clippy::all)]
                pub fn commit(&self) -> Result<(), Error> {
                    unsafe {
                        #[repr(align(4))]
                        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 = "golem:rdbms/postgres@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-transaction.commit"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(4).cast::<u8>());
                                    let v18 = match l2 {
                                        0 => {
                                            let e18 = {
                                                let l3 = *ptr0.add(8).cast::<*mut u8>();
                                                let l4 = *ptr0.add(12).cast::<usize>();
                                                let len5 = l4;
                                                let bytes5 = _rt::Vec::from_raw_parts(
                                                    l3.cast(),
                                                    len5,
                                                    len5,
                                                );
                                                _rt::string_lift(bytes5)
                                            };
                                            Error::ConnectionFailure(e18)
                                        }
                                        1 => {
                                            let e18 = {
                                                let l6 = *ptr0.add(8).cast::<*mut u8>();
                                                let l7 = *ptr0.add(12).cast::<usize>();
                                                let len8 = l7;
                                                let bytes8 = _rt::Vec::from_raw_parts(
                                                    l6.cast(),
                                                    len8,
                                                    len8,
                                                );
                                                _rt::string_lift(bytes8)
                                            };
                                            Error::QueryParameterFailure(e18)
                                        }
                                        2 => {
                                            let e18 = {
                                                let l9 = *ptr0.add(8).cast::<*mut u8>();
                                                let l10 = *ptr0.add(12).cast::<usize>();
                                                let len11 = l10;
                                                let bytes11 = _rt::Vec::from_raw_parts(
                                                    l9.cast(),
                                                    len11,
                                                    len11,
                                                );
                                                _rt::string_lift(bytes11)
                                            };
                                            Error::QueryExecutionFailure(e18)
                                        }
                                        3 => {
                                            let e18 = {
                                                let l12 = *ptr0.add(8).cast::<*mut u8>();
                                                let l13 = *ptr0.add(12).cast::<usize>();
                                                let len14 = l13;
                                                let bytes14 = _rt::Vec::from_raw_parts(
                                                    l12.cast(),
                                                    len14,
                                                    len14,
                                                );
                                                _rt::string_lift(bytes14)
                                            };
                                            Error::QueryResponseFailure(e18)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 4, "invalid enum discriminant");
                                            let e18 = {
                                                let l15 = *ptr0.add(8).cast::<*mut u8>();
                                                let l16 = *ptr0.add(12).cast::<usize>();
                                                let len17 = l16;
                                                let bytes17 = _rt::Vec::from_raw_parts(
                                                    l15.cast(),
                                                    len17,
                                                    len17,
                                                );
                                                _rt::string_lift(bytes17)
                                            };
                                            Error::Other(e18)
                                        }
                                    };
                                    v18
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl DbTransaction {
                #[allow(unused_unsafe, clippy::all)]
                pub fn rollback(&self) -> Result<(), Error> {
                    unsafe {
                        #[repr(align(4))]
                        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 = "golem:rdbms/postgres@0.0.1")]
                        extern "C" {
                            #[link_name = "[method]db-transaction.rollback"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(4).cast::<u8>());
                                    let v18 = match l2 {
                                        0 => {
                                            let e18 = {
                                                let l3 = *ptr0.add(8).cast::<*mut u8>();
                                                let l4 = *ptr0.add(12).cast::<usize>();
                                                let len5 = l4;
                                                let bytes5 = _rt::Vec::from_raw_parts(
                                                    l3.cast(),
                                                    len5,
                                                    len5,
                                                );
                                                _rt::string_lift(bytes5)
                                            };
                                            Error::ConnectionFailure(e18)
                                        }
                                        1 => {
                                            let e18 = {
                                                let l6 = *ptr0.add(8).cast::<*mut u8>();
                                                let l7 = *ptr0.add(12).cast::<usize>();
                                                let len8 = l7;
                                                let bytes8 = _rt::Vec::from_raw_parts(
                                                    l6.cast(),
                                                    len8,
                                                    len8,
                                                );
                                                _rt::string_lift(bytes8)
                                            };
                                            Error::QueryParameterFailure(e18)
                                        }
                                        2 => {
                                            let e18 = {
                                                let l9 = *ptr0.add(8).cast::<*mut u8>();
                                                let l10 = *ptr0.add(12).cast::<usize>();
                                                let len11 = l10;
                                                let bytes11 = _rt::Vec::from_raw_parts(
                                                    l9.cast(),
                                                    len11,
                                                    len11,
                                                );
                                                _rt::string_lift(bytes11)
                                            };
                                            Error::QueryExecutionFailure(e18)
                                        }
                                        3 => {
                                            let e18 = {
                                                let l12 = *ptr0.add(8).cast::<*mut u8>();
                                                let l13 = *ptr0.add(12).cast::<usize>();
                                                let len14 = l13;
                                                let bytes14 = _rt::Vec::from_raw_parts(
                                                    l12.cast(),
                                                    len14,
                                                    len14,
                                                );
                                                _rt::string_lift(bytes14)
                                            };
                                            Error::QueryResponseFailure(e18)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 4, "invalid enum discriminant");
                                            let e18 = {
                                                let l15 = *ptr0.add(8).cast::<*mut u8>();
                                                let l16 = *ptr0.add(12).cast::<usize>();
                                                let len17 = l16;
                                                let bytes17 = _rt::Vec::from_raw_parts(
                                                    l15.cast(),
                                                    len17,
                                                    len17,
                                                );
                                                _rt::string_lift(bytes17)
                                            };
                                            Error::Other(e18)
                                        }
                                    };
                                    v18
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
        }
    }
    pub mod rpc {
        #[allow(dead_code, 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 Datetime = super::super::super::wasi::clocks::wall_clock::Datetime;
            pub type Pollable = super::super::super::wasi::io::poll::Pollable;
            pub type NodeIndex = i32;
            pub type ResourceId = u64;
            #[repr(u8)]
            #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
            pub enum ResourceMode {
                Owned,
                Borrowed,
            }
            impl ::core::fmt::Debug for ResourceMode {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        ResourceMode::Owned => {
                            f.debug_tuple("ResourceMode::Owned").finish()
                        }
                        ResourceMode::Borrowed => {
                            f.debug_tuple("ResourceMode::Borrowed").finish()
                        }
                    }
                }
            }
            impl ResourceMode {
                #[doc(hidden)]
                pub unsafe fn _lift(val: u8) -> ResourceMode {
                    if !cfg!(debug_assertions) {
                        return ::core::mem::transmute(val);
                    }
                    match val {
                        0 => ResourceMode::Owned,
                        1 => ResourceMode::Borrowed,
                        _ => panic!("invalid enum discriminant"),
                    }
                }
            }
            #[derive(Clone)]
            pub enum WitTypeNode {
                RecordType(_rt::Vec<(_rt::String, NodeIndex)>),
                VariantType(_rt::Vec<(_rt::String, Option<NodeIndex>)>),
                EnumType(_rt::Vec<_rt::String>),
                FlagsType(_rt::Vec<_rt::String>),
                TupleType(_rt::Vec<NodeIndex>),
                ListType(NodeIndex),
                OptionType(NodeIndex),
                ResultType((Option<NodeIndex>, Option<NodeIndex>)),
                PrimU8Type,
                PrimU16Type,
                PrimU32Type,
                PrimU64Type,
                PrimS8Type,
                PrimS16Type,
                PrimS32Type,
                PrimS64Type,
                PrimF32Type,
                PrimF64Type,
                PrimCharType,
                PrimBoolType,
                PrimStringType,
                HandleType((ResourceId, ResourceMode)),
            }
            impl ::core::fmt::Debug for WitTypeNode {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        WitTypeNode::RecordType(e) => {
                            f.debug_tuple("WitTypeNode::RecordType").field(e).finish()
                        }
                        WitTypeNode::VariantType(e) => {
                            f.debug_tuple("WitTypeNode::VariantType").field(e).finish()
                        }
                        WitTypeNode::EnumType(e) => {
                            f.debug_tuple("WitTypeNode::EnumType").field(e).finish()
                        }
                        WitTypeNode::FlagsType(e) => {
                            f.debug_tuple("WitTypeNode::FlagsType").field(e).finish()
                        }
                        WitTypeNode::TupleType(e) => {
                            f.debug_tuple("WitTypeNode::TupleType").field(e).finish()
                        }
                        WitTypeNode::ListType(e) => {
                            f.debug_tuple("WitTypeNode::ListType").field(e).finish()
                        }
                        WitTypeNode::OptionType(e) => {
                            f.debug_tuple("WitTypeNode::OptionType").field(e).finish()
                        }
                        WitTypeNode::ResultType(e) => {
                            f.debug_tuple("WitTypeNode::ResultType").field(e).finish()
                        }
                        WitTypeNode::PrimU8Type => {
                            f.debug_tuple("WitTypeNode::PrimU8Type").finish()
                        }
                        WitTypeNode::PrimU16Type => {
                            f.debug_tuple("WitTypeNode::PrimU16Type").finish()
                        }
                        WitTypeNode::PrimU32Type => {
                            f.debug_tuple("WitTypeNode::PrimU32Type").finish()
                        }
                        WitTypeNode::PrimU64Type => {
                            f.debug_tuple("WitTypeNode::PrimU64Type").finish()
                        }
                        WitTypeNode::PrimS8Type => {
                            f.debug_tuple("WitTypeNode::PrimS8Type").finish()
                        }
                        WitTypeNode::PrimS16Type => {
                            f.debug_tuple("WitTypeNode::PrimS16Type").finish()
                        }
                        WitTypeNode::PrimS32Type => {
                            f.debug_tuple("WitTypeNode::PrimS32Type").finish()
                        }
                        WitTypeNode::PrimS64Type => {
                            f.debug_tuple("WitTypeNode::PrimS64Type").finish()
                        }
                        WitTypeNode::PrimF32Type => {
                            f.debug_tuple("WitTypeNode::PrimF32Type").finish()
                        }
                        WitTypeNode::PrimF64Type => {
                            f.debug_tuple("WitTypeNode::PrimF64Type").finish()
                        }
                        WitTypeNode::PrimCharType => {
                            f.debug_tuple("WitTypeNode::PrimCharType").finish()
                        }
                        WitTypeNode::PrimBoolType => {
                            f.debug_tuple("WitTypeNode::PrimBoolType").finish()
                        }
                        WitTypeNode::PrimStringType => {
                            f.debug_tuple("WitTypeNode::PrimStringType").finish()
                        }
                        WitTypeNode::HandleType(e) => {
                            f.debug_tuple("WitTypeNode::HandleType").field(e).finish()
                        }
                    }
                }
            }
            #[derive(Clone)]
            pub struct WitType {
                pub nodes: _rt::Vec<WitTypeNode>,
            }
            impl ::core::fmt::Debug for WitType {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("WitType").field("nodes", &self.nodes).finish()
                }
            }
            #[derive(Clone)]
            pub struct Uri {
                pub value: _rt::String,
            }
            impl ::core::fmt::Debug for Uri {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Uri").field("value", &self.value).finish()
                }
            }
            #[derive(Clone)]
            pub enum WitNode {
                RecordValue(_rt::Vec<NodeIndex>),
                VariantValue((u32, Option<NodeIndex>)),
                EnumValue(u32),
                FlagsValue(_rt::Vec<bool>),
                TupleValue(_rt::Vec<NodeIndex>),
                ListValue(_rt::Vec<NodeIndex>),
                OptionValue(Option<NodeIndex>),
                ResultValue(Result<Option<NodeIndex>, Option<NodeIndex>>),
                PrimU8(u8),
                PrimU16(u16),
                PrimU32(u32),
                PrimU64(u64),
                PrimS8(i8),
                PrimS16(i16),
                PrimS32(i32),
                PrimS64(i64),
                PrimFloat32(f32),
                PrimFloat64(f64),
                PrimChar(char),
                PrimBool(bool),
                PrimString(_rt::String),
                Handle((Uri, u64)),
            }
            impl ::core::fmt::Debug for WitNode {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        WitNode::RecordValue(e) => {
                            f.debug_tuple("WitNode::RecordValue").field(e).finish()
                        }
                        WitNode::VariantValue(e) => {
                            f.debug_tuple("WitNode::VariantValue").field(e).finish()
                        }
                        WitNode::EnumValue(e) => {
                            f.debug_tuple("WitNode::EnumValue").field(e).finish()
                        }
                        WitNode::FlagsValue(e) => {
                            f.debug_tuple("WitNode::FlagsValue").field(e).finish()
                        }
                        WitNode::TupleValue(e) => {
                            f.debug_tuple("WitNode::TupleValue").field(e).finish()
                        }
                        WitNode::ListValue(e) => {
                            f.debug_tuple("WitNode::ListValue").field(e).finish()
                        }
                        WitNode::OptionValue(e) => {
                            f.debug_tuple("WitNode::OptionValue").field(e).finish()
                        }
                        WitNode::ResultValue(e) => {
                            f.debug_tuple("WitNode::ResultValue").field(e).finish()
                        }
                        WitNode::PrimU8(e) => {
                            f.debug_tuple("WitNode::PrimU8").field(e).finish()
                        }
                        WitNode::PrimU16(e) => {
                            f.debug_tuple("WitNode::PrimU16").field(e).finish()
                        }
                        WitNode::PrimU32(e) => {
                            f.debug_tuple("WitNode::PrimU32").field(e).finish()
                        }
                        WitNode::PrimU64(e) => {
                            f.debug_tuple("WitNode::PrimU64").field(e).finish()
                        }
                        WitNode::PrimS8(e) => {
                            f.debug_tuple("WitNode::PrimS8").field(e).finish()
                        }
                        WitNode::PrimS16(e) => {
                            f.debug_tuple("WitNode::PrimS16").field(e).finish()
                        }
                        WitNode::PrimS32(e) => {
                            f.debug_tuple("WitNode::PrimS32").field(e).finish()
                        }
                        WitNode::PrimS64(e) => {
                            f.debug_tuple("WitNode::PrimS64").field(e).finish()
                        }
                        WitNode::PrimFloat32(e) => {
                            f.debug_tuple("WitNode::PrimFloat32").field(e).finish()
                        }
                        WitNode::PrimFloat64(e) => {
                            f.debug_tuple("WitNode::PrimFloat64").field(e).finish()
                        }
                        WitNode::PrimChar(e) => {
                            f.debug_tuple("WitNode::PrimChar").field(e).finish()
                        }
                        WitNode::PrimBool(e) => {
                            f.debug_tuple("WitNode::PrimBool").field(e).finish()
                        }
                        WitNode::PrimString(e) => {
                            f.debug_tuple("WitNode::PrimString").field(e).finish()
                        }
                        WitNode::Handle(e) => {
                            f.debug_tuple("WitNode::Handle").field(e).finish()
                        }
                    }
                }
            }
            #[derive(Clone)]
            pub struct WitValue {
                pub nodes: _rt::Vec<WitNode>,
            }
            impl ::core::fmt::Debug for WitValue {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("WitValue").field("nodes", &self.nodes).finish()
                }
            }
            #[derive(Clone)]
            pub struct ValueAndType {
                pub value: WitValue,
                pub typ: WitType,
            }
            impl ::core::fmt::Debug for ValueAndType {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("ValueAndType")
                        .field("value", &self.value)
                        .field("typ", &self.typ)
                        .finish()
                }
            }
            #[derive(Clone)]
            pub enum RpcError {
                ProtocolError(_rt::String),
                Denied(_rt::String),
                NotFound(_rt::String),
                RemoteInternalError(_rt::String),
            }
            impl ::core::fmt::Debug for RpcError {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        RpcError::ProtocolError(e) => {
                            f.debug_tuple("RpcError::ProtocolError").field(e).finish()
                        }
                        RpcError::Denied(e) => {
                            f.debug_tuple("RpcError::Denied").field(e).finish()
                        }
                        RpcError::NotFound(e) => {
                            f.debug_tuple("RpcError::NotFound").field(e).finish()
                        }
                        RpcError::RemoteInternalError(e) => {
                            f.debug_tuple("RpcError::RemoteInternalError")
                                .field(e)
                                .finish()
                        }
                    }
                }
            }
            impl ::core::fmt::Display for RpcError {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    write!(f, "{:?}", self)
                }
            }
            impl std::error::Error for RpcError {}
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct WasmRpc {
                handle: _rt::Resource<WasmRpc>,
            }
            impl WasmRpc {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 WasmRpc {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "golem:rpc/types@0.1.3")]
                        extern "C" {
                            #[link_name = "[resource-drop]wasm-rpc"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct FutureInvokeResult {
                handle: _rt::Resource<FutureInvokeResult>,
            }
            impl FutureInvokeResult {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 FutureInvokeResult {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "golem:rpc/types@0.1.3")]
                        extern "C" {
                            #[link_name = "[resource-drop]future-invoke-result"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct CancellationToken {
                handle: _rt::Resource<CancellationToken>,
            }
            impl CancellationToken {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 CancellationToken {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "golem:rpc/types@0.1.3")]
                        extern "C" {
                            #[link_name = "[resource-drop]cancellation-token"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            impl WasmRpc {
                #[allow(unused_unsafe, clippy::all)]
                pub fn new(location: &Uri) -> Self {
                    unsafe {
                        let Uri { value: value0 } = location;
                        let vec1 = value0;
                        let ptr1 = vec1.as_ptr().cast::<u8>();
                        let len1 = vec1.len();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rpc/types@0.1.3")]
                        extern "C" {
                            #[link_name = "[constructor]wasm-rpc"]
                            fn wit_import(_: *mut u8, _: usize) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: *mut u8, _: usize) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import(ptr1.cast_mut(), len1);
                        WasmRpc::from_handle(ret as u32)
                    }
                }
            }
            impl WasmRpc {
                #[allow(unused_unsafe, clippy::all)]
                pub fn invoke_and_await(
                    &self,
                    function_name: &str,
                    function_params: &[WitValue],
                ) -> Result<WitValue, RpcError> {
                    unsafe {
                        let mut cleanup_list = _rt::Vec::new();
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 16]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 16],
                        );
                        let vec0 = function_name;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let vec12 = function_params;
                        let len12 = vec12.len();
                        let layout12 = _rt::alloc::Layout::from_size_align_unchecked(
                            vec12.len() * 8,
                            4,
                        );
                        let result12 = if layout12.size() != 0 {
                            let ptr = _rt::alloc::alloc(layout12).cast::<u8>();
                            if ptr.is_null() {
                                _rt::alloc::handle_alloc_error(layout12);
                            }
                            ptr
                        } else {
                            ::core::ptr::null_mut()
                        };
                        for (i, e) in vec12.into_iter().enumerate() {
                            let base = result12.add(i * 8);
                            {
                                let WitValue { nodes: nodes1 } = e;
                                let vec11 = nodes1;
                                let len11 = vec11.len();
                                let layout11 = _rt::alloc::Layout::from_size_align_unchecked(
                                    vec11.len() * 24,
                                    8,
                                );
                                let result11 = if layout11.size() != 0 {
                                    let ptr = _rt::alloc::alloc(layout11).cast::<u8>();
                                    if ptr.is_null() {
                                        _rt::alloc::handle_alloc_error(layout11);
                                    }
                                    ptr
                                } else {
                                    ::core::ptr::null_mut()
                                };
                                for (i, e) in vec11.into_iter().enumerate() {
                                    let base = result11.add(i * 24);
                                    {
                                        match e {
                                            WitNode::RecordValue(e) => {
                                                *base.add(0).cast::<u8>() = (0i32) as u8;
                                                let vec2 = e;
                                                let ptr2 = vec2.as_ptr().cast::<u8>();
                                                let len2 = vec2.len();
                                                *base.add(12).cast::<usize>() = len2;
                                                *base.add(8).cast::<*mut u8>() = ptr2.cast_mut();
                                            }
                                            WitNode::VariantValue(e) => {
                                                *base.add(0).cast::<u8>() = (1i32) as u8;
                                                let (t3_0, t3_1) = e;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(t3_0);
                                                match t3_1 {
                                                    Some(e) => {
                                                        *base.add(12).cast::<u8>() = (1i32) as u8;
                                                        *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                    }
                                                    None => {
                                                        *base.add(12).cast::<u8>() = (0i32) as u8;
                                                    }
                                                };
                                            }
                                            WitNode::EnumValue(e) => {
                                                *base.add(0).cast::<u8>() = (2i32) as u8;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            WitNode::FlagsValue(e) => {
                                                *base.add(0).cast::<u8>() = (3i32) as u8;
                                                let vec4 = e;
                                                let len4 = vec4.len();
                                                let layout4 = _rt::alloc::Layout::from_size_align_unchecked(
                                                    vec4.len() * 1,
                                                    1,
                                                );
                                                let result4 = if layout4.size() != 0 {
                                                    let ptr = _rt::alloc::alloc(layout4).cast::<u8>();
                                                    if ptr.is_null() {
                                                        _rt::alloc::handle_alloc_error(layout4);
                                                    }
                                                    ptr
                                                } else {
                                                    ::core::ptr::null_mut()
                                                };
                                                for (i, e) in vec4.into_iter().enumerate() {
                                                    let base = result4.add(i * 1);
                                                    {
                                                        *base.add(0).cast::<u8>() = (match e {
                                                            true => 1,
                                                            false => 0,
                                                        }) as u8;
                                                    }
                                                }
                                                *base.add(12).cast::<usize>() = len4;
                                                *base.add(8).cast::<*mut u8>() = result4;
                                                cleanup_list.extend_from_slice(&[(result4, layout4)]);
                                            }
                                            WitNode::TupleValue(e) => {
                                                *base.add(0).cast::<u8>() = (4i32) as u8;
                                                let vec5 = e;
                                                let ptr5 = vec5.as_ptr().cast::<u8>();
                                                let len5 = vec5.len();
                                                *base.add(12).cast::<usize>() = len5;
                                                *base.add(8).cast::<*mut u8>() = ptr5.cast_mut();
                                            }
                                            WitNode::ListValue(e) => {
                                                *base.add(0).cast::<u8>() = (5i32) as u8;
                                                let vec6 = e;
                                                let ptr6 = vec6.as_ptr().cast::<u8>();
                                                let len6 = vec6.len();
                                                *base.add(12).cast::<usize>() = len6;
                                                *base.add(8).cast::<*mut u8>() = ptr6.cast_mut();
                                            }
                                            WitNode::OptionValue(e) => {
                                                *base.add(0).cast::<u8>() = (6i32) as u8;
                                                match e {
                                                    Some(e) => {
                                                        *base.add(8).cast::<u8>() = (1i32) as u8;
                                                        *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                                    }
                                                    None => {
                                                        *base.add(8).cast::<u8>() = (0i32) as u8;
                                                    }
                                                };
                                            }
                                            WitNode::ResultValue(e) => {
                                                *base.add(0).cast::<u8>() = (7i32) as u8;
                                                match e {
                                                    Ok(e) => {
                                                        *base.add(8).cast::<u8>() = (0i32) as u8;
                                                        match e {
                                                            Some(e) => {
                                                                *base.add(12).cast::<u8>() = (1i32) as u8;
                                                                *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                            }
                                                            None => {
                                                                *base.add(12).cast::<u8>() = (0i32) as u8;
                                                            }
                                                        };
                                                    }
                                                    Err(e) => {
                                                        *base.add(8).cast::<u8>() = (1i32) as u8;
                                                        match e {
                                                            Some(e) => {
                                                                *base.add(12).cast::<u8>() = (1i32) as u8;
                                                                *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                            }
                                                            None => {
                                                                *base.add(12).cast::<u8>() = (0i32) as u8;
                                                            }
                                                        };
                                                    }
                                                };
                                            }
                                            WitNode::PrimU8(e) => {
                                                *base.add(0).cast::<u8>() = (8i32) as u8;
                                                *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                            }
                                            WitNode::PrimU16(e) => {
                                                *base.add(0).cast::<u8>() = (9i32) as u8;
                                                *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                            }
                                            WitNode::PrimU32(e) => {
                                                *base.add(0).cast::<u8>() = (10i32) as u8;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            WitNode::PrimU64(e) => {
                                                *base.add(0).cast::<u8>() = (11i32) as u8;
                                                *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            WitNode::PrimS8(e) => {
                                                *base.add(0).cast::<u8>() = (12i32) as u8;
                                                *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                            }
                                            WitNode::PrimS16(e) => {
                                                *base.add(0).cast::<u8>() = (13i32) as u8;
                                                *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                            }
                                            WitNode::PrimS32(e) => {
                                                *base.add(0).cast::<u8>() = (14i32) as u8;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            WitNode::PrimS64(e) => {
                                                *base.add(0).cast::<u8>() = (15i32) as u8;
                                                *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            WitNode::PrimFloat32(e) => {
                                                *base.add(0).cast::<u8>() = (16i32) as u8;
                                                *base.add(8).cast::<f32>() = _rt::as_f32(e);
                                            }
                                            WitNode::PrimFloat64(e) => {
                                                *base.add(0).cast::<u8>() = (17i32) as u8;
                                                *base.add(8).cast::<f64>() = _rt::as_f64(e);
                                            }
                                            WitNode::PrimChar(e) => {
                                                *base.add(0).cast::<u8>() = (18i32) as u8;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            WitNode::PrimBool(e) => {
                                                *base.add(0).cast::<u8>() = (19i32) as u8;
                                                *base.add(8).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                            WitNode::PrimString(e) => {
                                                *base.add(0).cast::<u8>() = (20i32) as u8;
                                                let vec7 = e;
                                                let ptr7 = vec7.as_ptr().cast::<u8>();
                                                let len7 = vec7.len();
                                                *base.add(12).cast::<usize>() = len7;
                                                *base.add(8).cast::<*mut u8>() = ptr7.cast_mut();
                                            }
                                            WitNode::Handle(e) => {
                                                *base.add(0).cast::<u8>() = (21i32) as u8;
                                                let (t8_0, t8_1) = e;
                                                let Uri { value: value9 } = t8_0;
                                                let vec10 = value9;
                                                let ptr10 = vec10.as_ptr().cast::<u8>();
                                                let len10 = vec10.len();
                                                *base.add(12).cast::<usize>() = len10;
                                                *base.add(8).cast::<*mut u8>() = ptr10.cast_mut();
                                                *base.add(16).cast::<i64>() = _rt::as_i64(t8_1);
                                            }
                                        }
                                    }
                                }
                                *base.add(4).cast::<usize>() = len11;
                                *base.add(0).cast::<*mut u8>() = result11;
                                cleanup_list.extend_from_slice(&[(result11, layout11)]);
                            }
                        }
                        let ptr13 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rpc/types@0.1.3")]
                        extern "C" {
                            #[link_name = "[method]wasm-rpc.invoke-and-await"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            result12,
                            len12,
                            ptr13,
                        );
                        let l14 = i32::from(*ptr13.add(0).cast::<u8>());
                        if layout12.size() != 0 {
                            _rt::alloc::dealloc(result12.cast(), layout12);
                        }
                        for (ptr, layout) in cleanup_list {
                            if layout.size() != 0 {
                                _rt::alloc::dealloc(ptr.cast(), layout);
                            }
                        }
                        match l14 {
                            0 => {
                                let e = {
                                    let l15 = *ptr13.add(4).cast::<*mut u8>();
                                    let l16 = *ptr13.add(8).cast::<usize>();
                                    let base62 = l15;
                                    let len62 = l16;
                                    let mut result62 = _rt::Vec::with_capacity(len62);
                                    for i in 0..len62 {
                                        let base = base62.add(i * 24);
                                        let e62 = {
                                            let l17 = i32::from(*base.add(0).cast::<u8>());
                                            let v61 = match l17 {
                                                0 => {
                                                    let e61 = {
                                                        let l18 = *base.add(8).cast::<*mut u8>();
                                                        let l19 = *base.add(12).cast::<usize>();
                                                        let len20 = l19;
                                                        _rt::Vec::from_raw_parts(l18.cast(), len20, len20)
                                                    };
                                                    WitNode::RecordValue(e61)
                                                }
                                                1 => {
                                                    let e61 = {
                                                        let l21 = *base.add(8).cast::<i32>();
                                                        let l22 = i32::from(*base.add(12).cast::<u8>());
                                                        (
                                                            l21 as u32,
                                                            match l22 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l23 = *base.add(16).cast::<i32>();
                                                                        l23
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                        )
                                                    };
                                                    WitNode::VariantValue(e61)
                                                }
                                                2 => {
                                                    let e61 = {
                                                        let l24 = *base.add(8).cast::<i32>();
                                                        l24 as u32
                                                    };
                                                    WitNode::EnumValue(e61)
                                                }
                                                3 => {
                                                    let e61 = {
                                                        let l25 = *base.add(8).cast::<*mut u8>();
                                                        let l26 = *base.add(12).cast::<usize>();
                                                        let base28 = l25;
                                                        let len28 = l26;
                                                        let mut result28 = _rt::Vec::with_capacity(len28);
                                                        for i in 0..len28 {
                                                            let base = base28.add(i * 1);
                                                            let e28 = {
                                                                let l27 = i32::from(*base.add(0).cast::<u8>());
                                                                _rt::bool_lift(l27 as u8)
                                                            };
                                                            result28.push(e28);
                                                        }
                                                        _rt::cabi_dealloc(base28, len28 * 1, 1);
                                                        result28
                                                    };
                                                    WitNode::FlagsValue(e61)
                                                }
                                                4 => {
                                                    let e61 = {
                                                        let l29 = *base.add(8).cast::<*mut u8>();
                                                        let l30 = *base.add(12).cast::<usize>();
                                                        let len31 = l30;
                                                        _rt::Vec::from_raw_parts(l29.cast(), len31, len31)
                                                    };
                                                    WitNode::TupleValue(e61)
                                                }
                                                5 => {
                                                    let e61 = {
                                                        let l32 = *base.add(8).cast::<*mut u8>();
                                                        let l33 = *base.add(12).cast::<usize>();
                                                        let len34 = l33;
                                                        _rt::Vec::from_raw_parts(l32.cast(), len34, len34)
                                                    };
                                                    WitNode::ListValue(e61)
                                                }
                                                6 => {
                                                    let e61 = {
                                                        let l35 = i32::from(*base.add(8).cast::<u8>());
                                                        match l35 {
                                                            0 => None,
                                                            1 => {
                                                                let e = {
                                                                    let l36 = *base.add(12).cast::<i32>();
                                                                    l36
                                                                };
                                                                Some(e)
                                                            }
                                                            _ => _rt::invalid_enum_discriminant(),
                                                        }
                                                    };
                                                    WitNode::OptionValue(e61)
                                                }
                                                7 => {
                                                    let e61 = {
                                                        let l37 = i32::from(*base.add(8).cast::<u8>());
                                                        match l37 {
                                                            0 => {
                                                                let e = {
                                                                    let l38 = i32::from(*base.add(12).cast::<u8>());
                                                                    match l38 {
                                                                        0 => None,
                                                                        1 => {
                                                                            let e = {
                                                                                let l39 = *base.add(16).cast::<i32>();
                                                                                l39
                                                                            };
                                                                            Some(e)
                                                                        }
                                                                        _ => _rt::invalid_enum_discriminant(),
                                                                    }
                                                                };
                                                                Ok(e)
                                                            }
                                                            1 => {
                                                                let e = {
                                                                    let l40 = i32::from(*base.add(12).cast::<u8>());
                                                                    match l40 {
                                                                        0 => None,
                                                                        1 => {
                                                                            let e = {
                                                                                let l41 = *base.add(16).cast::<i32>();
                                                                                l41
                                                                            };
                                                                            Some(e)
                                                                        }
                                                                        _ => _rt::invalid_enum_discriminant(),
                                                                    }
                                                                };
                                                                Err(e)
                                                            }
                                                            _ => _rt::invalid_enum_discriminant(),
                                                        }
                                                    };
                                                    WitNode::ResultValue(e61)
                                                }
                                                8 => {
                                                    let e61 = {
                                                        let l42 = i32::from(*base.add(8).cast::<u8>());
                                                        l42 as u8
                                                    };
                                                    WitNode::PrimU8(e61)
                                                }
                                                9 => {
                                                    let e61 = {
                                                        let l43 = i32::from(*base.add(8).cast::<u16>());
                                                        l43 as u16
                                                    };
                                                    WitNode::PrimU16(e61)
                                                }
                                                10 => {
                                                    let e61 = {
                                                        let l44 = *base.add(8).cast::<i32>();
                                                        l44 as u32
                                                    };
                                                    WitNode::PrimU32(e61)
                                                }
                                                11 => {
                                                    let e61 = {
                                                        let l45 = *base.add(8).cast::<i64>();
                                                        l45 as u64
                                                    };
                                                    WitNode::PrimU64(e61)
                                                }
                                                12 => {
                                                    let e61 = {
                                                        let l46 = i32::from(*base.add(8).cast::<i8>());
                                                        l46 as i8
                                                    };
                                                    WitNode::PrimS8(e61)
                                                }
                                                13 => {
                                                    let e61 = {
                                                        let l47 = i32::from(*base.add(8).cast::<i16>());
                                                        l47 as i16
                                                    };
                                                    WitNode::PrimS16(e61)
                                                }
                                                14 => {
                                                    let e61 = {
                                                        let l48 = *base.add(8).cast::<i32>();
                                                        l48
                                                    };
                                                    WitNode::PrimS32(e61)
                                                }
                                                15 => {
                                                    let e61 = {
                                                        let l49 = *base.add(8).cast::<i64>();
                                                        l49
                                                    };
                                                    WitNode::PrimS64(e61)
                                                }
                                                16 => {
                                                    let e61 = {
                                                        let l50 = *base.add(8).cast::<f32>();
                                                        l50
                                                    };
                                                    WitNode::PrimFloat32(e61)
                                                }
                                                17 => {
                                                    let e61 = {
                                                        let l51 = *base.add(8).cast::<f64>();
                                                        l51
                                                    };
                                                    WitNode::PrimFloat64(e61)
                                                }
                                                18 => {
                                                    let e61 = {
                                                        let l52 = *base.add(8).cast::<i32>();
                                                        _rt::char_lift(l52 as u32)
                                                    };
                                                    WitNode::PrimChar(e61)
                                                }
                                                19 => {
                                                    let e61 = {
                                                        let l53 = i32::from(*base.add(8).cast::<u8>());
                                                        _rt::bool_lift(l53 as u8)
                                                    };
                                                    WitNode::PrimBool(e61)
                                                }
                                                20 => {
                                                    let e61 = {
                                                        let l54 = *base.add(8).cast::<*mut u8>();
                                                        let l55 = *base.add(12).cast::<usize>();
                                                        let len56 = l55;
                                                        let bytes56 = _rt::Vec::from_raw_parts(
                                                            l54.cast(),
                                                            len56,
                                                            len56,
                                                        );
                                                        _rt::string_lift(bytes56)
                                                    };
                                                    WitNode::PrimString(e61)
                                                }
                                                n => {
                                                    debug_assert_eq!(n, 21, "invalid enum discriminant");
                                                    let e61 = {
                                                        let l57 = *base.add(8).cast::<*mut u8>();
                                                        let l58 = *base.add(12).cast::<usize>();
                                                        let len59 = l58;
                                                        let bytes59 = _rt::Vec::from_raw_parts(
                                                            l57.cast(),
                                                            len59,
                                                            len59,
                                                        );
                                                        let l60 = *base.add(16).cast::<i64>();
                                                        (
                                                            Uri {
                                                                value: _rt::string_lift(bytes59),
                                                            },
                                                            l60 as u64,
                                                        )
                                                    };
                                                    WitNode::Handle(e61)
                                                }
                                            };
                                            v61
                                        };
                                        result62.push(e62);
                                    }
                                    _rt::cabi_dealloc(base62, len62 * 24, 8);
                                    WitValue { nodes: result62 }
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l63 = i32::from(*ptr13.add(4).cast::<u8>());
                                    let v76 = match l63 {
                                        0 => {
                                            let e76 = {
                                                let l64 = *ptr13.add(8).cast::<*mut u8>();
                                                let l65 = *ptr13.add(12).cast::<usize>();
                                                let len66 = l65;
                                                let bytes66 = _rt::Vec::from_raw_parts(
                                                    l64.cast(),
                                                    len66,
                                                    len66,
                                                );
                                                _rt::string_lift(bytes66)
                                            };
                                            RpcError::ProtocolError(e76)
                                        }
                                        1 => {
                                            let e76 = {
                                                let l67 = *ptr13.add(8).cast::<*mut u8>();
                                                let l68 = *ptr13.add(12).cast::<usize>();
                                                let len69 = l68;
                                                let bytes69 = _rt::Vec::from_raw_parts(
                                                    l67.cast(),
                                                    len69,
                                                    len69,
                                                );
                                                _rt::string_lift(bytes69)
                                            };
                                            RpcError::Denied(e76)
                                        }
                                        2 => {
                                            let e76 = {
                                                let l70 = *ptr13.add(8).cast::<*mut u8>();
                                                let l71 = *ptr13.add(12).cast::<usize>();
                                                let len72 = l71;
                                                let bytes72 = _rt::Vec::from_raw_parts(
                                                    l70.cast(),
                                                    len72,
                                                    len72,
                                                );
                                                _rt::string_lift(bytes72)
                                            };
                                            RpcError::NotFound(e76)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 3, "invalid enum discriminant");
                                            let e76 = {
                                                let l73 = *ptr13.add(8).cast::<*mut u8>();
                                                let l74 = *ptr13.add(12).cast::<usize>();
                                                let len75 = l74;
                                                let bytes75 = _rt::Vec::from_raw_parts(
                                                    l73.cast(),
                                                    len75,
                                                    len75,
                                                );
                                                _rt::string_lift(bytes75)
                                            };
                                            RpcError::RemoteInternalError(e76)
                                        }
                                    };
                                    v76
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl WasmRpc {
                #[allow(unused_unsafe, clippy::all)]
                pub fn invoke(
                    &self,
                    function_name: &str,
                    function_params: &[WitValue],
                ) -> Result<(), RpcError> {
                    unsafe {
                        let mut cleanup_list = _rt::Vec::new();
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 16]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 16],
                        );
                        let vec0 = function_name;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let vec12 = function_params;
                        let len12 = vec12.len();
                        let layout12 = _rt::alloc::Layout::from_size_align_unchecked(
                            vec12.len() * 8,
                            4,
                        );
                        let result12 = if layout12.size() != 0 {
                            let ptr = _rt::alloc::alloc(layout12).cast::<u8>();
                            if ptr.is_null() {
                                _rt::alloc::handle_alloc_error(layout12);
                            }
                            ptr
                        } else {
                            ::core::ptr::null_mut()
                        };
                        for (i, e) in vec12.into_iter().enumerate() {
                            let base = result12.add(i * 8);
                            {
                                let WitValue { nodes: nodes1 } = e;
                                let vec11 = nodes1;
                                let len11 = vec11.len();
                                let layout11 = _rt::alloc::Layout::from_size_align_unchecked(
                                    vec11.len() * 24,
                                    8,
                                );
                                let result11 = if layout11.size() != 0 {
                                    let ptr = _rt::alloc::alloc(layout11).cast::<u8>();
                                    if ptr.is_null() {
                                        _rt::alloc::handle_alloc_error(layout11);
                                    }
                                    ptr
                                } else {
                                    ::core::ptr::null_mut()
                                };
                                for (i, e) in vec11.into_iter().enumerate() {
                                    let base = result11.add(i * 24);
                                    {
                                        match e {
                                            WitNode::RecordValue(e) => {
                                                *base.add(0).cast::<u8>() = (0i32) as u8;
                                                let vec2 = e;
                                                let ptr2 = vec2.as_ptr().cast::<u8>();
                                                let len2 = vec2.len();
                                                *base.add(12).cast::<usize>() = len2;
                                                *base.add(8).cast::<*mut u8>() = ptr2.cast_mut();
                                            }
                                            WitNode::VariantValue(e) => {
                                                *base.add(0).cast::<u8>() = (1i32) as u8;
                                                let (t3_0, t3_1) = e;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(t3_0);
                                                match t3_1 {
                                                    Some(e) => {
                                                        *base.add(12).cast::<u8>() = (1i32) as u8;
                                                        *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                    }
                                                    None => {
                                                        *base.add(12).cast::<u8>() = (0i32) as u8;
                                                    }
                                                };
                                            }
                                            WitNode::EnumValue(e) => {
                                                *base.add(0).cast::<u8>() = (2i32) as u8;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            WitNode::FlagsValue(e) => {
                                                *base.add(0).cast::<u8>() = (3i32) as u8;
                                                let vec4 = e;
                                                let len4 = vec4.len();
                                                let layout4 = _rt::alloc::Layout::from_size_align_unchecked(
                                                    vec4.len() * 1,
                                                    1,
                                                );
                                                let result4 = if layout4.size() != 0 {
                                                    let ptr = _rt::alloc::alloc(layout4).cast::<u8>();
                                                    if ptr.is_null() {
                                                        _rt::alloc::handle_alloc_error(layout4);
                                                    }
                                                    ptr
                                                } else {
                                                    ::core::ptr::null_mut()
                                                };
                                                for (i, e) in vec4.into_iter().enumerate() {
                                                    let base = result4.add(i * 1);
                                                    {
                                                        *base.add(0).cast::<u8>() = (match e {
                                                            true => 1,
                                                            false => 0,
                                                        }) as u8;
                                                    }
                                                }
                                                *base.add(12).cast::<usize>() = len4;
                                                *base.add(8).cast::<*mut u8>() = result4;
                                                cleanup_list.extend_from_slice(&[(result4, layout4)]);
                                            }
                                            WitNode::TupleValue(e) => {
                                                *base.add(0).cast::<u8>() = (4i32) as u8;
                                                let vec5 = e;
                                                let ptr5 = vec5.as_ptr().cast::<u8>();
                                                let len5 = vec5.len();
                                                *base.add(12).cast::<usize>() = len5;
                                                *base.add(8).cast::<*mut u8>() = ptr5.cast_mut();
                                            }
                                            WitNode::ListValue(e) => {
                                                *base.add(0).cast::<u8>() = (5i32) as u8;
                                                let vec6 = e;
                                                let ptr6 = vec6.as_ptr().cast::<u8>();
                                                let len6 = vec6.len();
                                                *base.add(12).cast::<usize>() = len6;
                                                *base.add(8).cast::<*mut u8>() = ptr6.cast_mut();
                                            }
                                            WitNode::OptionValue(e) => {
                                                *base.add(0).cast::<u8>() = (6i32) as u8;
                                                match e {
                                                    Some(e) => {
                                                        *base.add(8).cast::<u8>() = (1i32) as u8;
                                                        *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                                    }
                                                    None => {
                                                        *base.add(8).cast::<u8>() = (0i32) as u8;
                                                    }
                                                };
                                            }
                                            WitNode::ResultValue(e) => {
                                                *base.add(0).cast::<u8>() = (7i32) as u8;
                                                match e {
                                                    Ok(e) => {
                                                        *base.add(8).cast::<u8>() = (0i32) as u8;
                                                        match e {
                                                            Some(e) => {
                                                                *base.add(12).cast::<u8>() = (1i32) as u8;
                                                                *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                            }
                                                            None => {
                                                                *base.add(12).cast::<u8>() = (0i32) as u8;
                                                            }
                                                        };
                                                    }
                                                    Err(e) => {
                                                        *base.add(8).cast::<u8>() = (1i32) as u8;
                                                        match e {
                                                            Some(e) => {
                                                                *base.add(12).cast::<u8>() = (1i32) as u8;
                                                                *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                            }
                                                            None => {
                                                                *base.add(12).cast::<u8>() = (0i32) as u8;
                                                            }
                                                        };
                                                    }
                                                };
                                            }
                                            WitNode::PrimU8(e) => {
                                                *base.add(0).cast::<u8>() = (8i32) as u8;
                                                *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                            }
                                            WitNode::PrimU16(e) => {
                                                *base.add(0).cast::<u8>() = (9i32) as u8;
                                                *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                            }
                                            WitNode::PrimU32(e) => {
                                                *base.add(0).cast::<u8>() = (10i32) as u8;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            WitNode::PrimU64(e) => {
                                                *base.add(0).cast::<u8>() = (11i32) as u8;
                                                *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            WitNode::PrimS8(e) => {
                                                *base.add(0).cast::<u8>() = (12i32) as u8;
                                                *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                            }
                                            WitNode::PrimS16(e) => {
                                                *base.add(0).cast::<u8>() = (13i32) as u8;
                                                *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                            }
                                            WitNode::PrimS32(e) => {
                                                *base.add(0).cast::<u8>() = (14i32) as u8;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            WitNode::PrimS64(e) => {
                                                *base.add(0).cast::<u8>() = (15i32) as u8;
                                                *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            WitNode::PrimFloat32(e) => {
                                                *base.add(0).cast::<u8>() = (16i32) as u8;
                                                *base.add(8).cast::<f32>() = _rt::as_f32(e);
                                            }
                                            WitNode::PrimFloat64(e) => {
                                                *base.add(0).cast::<u8>() = (17i32) as u8;
                                                *base.add(8).cast::<f64>() = _rt::as_f64(e);
                                            }
                                            WitNode::PrimChar(e) => {
                                                *base.add(0).cast::<u8>() = (18i32) as u8;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            WitNode::PrimBool(e) => {
                                                *base.add(0).cast::<u8>() = (19i32) as u8;
                                                *base.add(8).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                            WitNode::PrimString(e) => {
                                                *base.add(0).cast::<u8>() = (20i32) as u8;
                                                let vec7 = e;
                                                let ptr7 = vec7.as_ptr().cast::<u8>();
                                                let len7 = vec7.len();
                                                *base.add(12).cast::<usize>() = len7;
                                                *base.add(8).cast::<*mut u8>() = ptr7.cast_mut();
                                            }
                                            WitNode::Handle(e) => {
                                                *base.add(0).cast::<u8>() = (21i32) as u8;
                                                let (t8_0, t8_1) = e;
                                                let Uri { value: value9 } = t8_0;
                                                let vec10 = value9;
                                                let ptr10 = vec10.as_ptr().cast::<u8>();
                                                let len10 = vec10.len();
                                                *base.add(12).cast::<usize>() = len10;
                                                *base.add(8).cast::<*mut u8>() = ptr10.cast_mut();
                                                *base.add(16).cast::<i64>() = _rt::as_i64(t8_1);
                                            }
                                        }
                                    }
                                }
                                *base.add(4).cast::<usize>() = len11;
                                *base.add(0).cast::<*mut u8>() = result11;
                                cleanup_list.extend_from_slice(&[(result11, layout11)]);
                            }
                        }
                        let ptr13 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rpc/types@0.1.3")]
                        extern "C" {
                            #[link_name = "[method]wasm-rpc.invoke"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            result12,
                            len12,
                            ptr13,
                        );
                        let l14 = i32::from(*ptr13.add(0).cast::<u8>());
                        if layout12.size() != 0 {
                            _rt::alloc::dealloc(result12.cast(), layout12);
                        }
                        for (ptr, layout) in cleanup_list {
                            if layout.size() != 0 {
                                _rt::alloc::dealloc(ptr.cast(), layout);
                            }
                        }
                        match l14 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l15 = i32::from(*ptr13.add(4).cast::<u8>());
                                    let v28 = match l15 {
                                        0 => {
                                            let e28 = {
                                                let l16 = *ptr13.add(8).cast::<*mut u8>();
                                                let l17 = *ptr13.add(12).cast::<usize>();
                                                let len18 = l17;
                                                let bytes18 = _rt::Vec::from_raw_parts(
                                                    l16.cast(),
                                                    len18,
                                                    len18,
                                                );
                                                _rt::string_lift(bytes18)
                                            };
                                            RpcError::ProtocolError(e28)
                                        }
                                        1 => {
                                            let e28 = {
                                                let l19 = *ptr13.add(8).cast::<*mut u8>();
                                                let l20 = *ptr13.add(12).cast::<usize>();
                                                let len21 = l20;
                                                let bytes21 = _rt::Vec::from_raw_parts(
                                                    l19.cast(),
                                                    len21,
                                                    len21,
                                                );
                                                _rt::string_lift(bytes21)
                                            };
                                            RpcError::Denied(e28)
                                        }
                                        2 => {
                                            let e28 = {
                                                let l22 = *ptr13.add(8).cast::<*mut u8>();
                                                let l23 = *ptr13.add(12).cast::<usize>();
                                                let len24 = l23;
                                                let bytes24 = _rt::Vec::from_raw_parts(
                                                    l22.cast(),
                                                    len24,
                                                    len24,
                                                );
                                                _rt::string_lift(bytes24)
                                            };
                                            RpcError::NotFound(e28)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 3, "invalid enum discriminant");
                                            let e28 = {
                                                let l25 = *ptr13.add(8).cast::<*mut u8>();
                                                let l26 = *ptr13.add(12).cast::<usize>();
                                                let len27 = l26;
                                                let bytes27 = _rt::Vec::from_raw_parts(
                                                    l25.cast(),
                                                    len27,
                                                    len27,
                                                );
                                                _rt::string_lift(bytes27)
                                            };
                                            RpcError::RemoteInternalError(e28)
                                        }
                                    };
                                    v28
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl WasmRpc {
                #[allow(unused_unsafe, clippy::all)]
                pub fn async_invoke_and_await(
                    &self,
                    function_name: &str,
                    function_params: &[WitValue],
                ) -> FutureInvokeResult {
                    unsafe {
                        let mut cleanup_list = _rt::Vec::new();
                        let vec0 = function_name;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let vec12 = function_params;
                        let len12 = vec12.len();
                        let layout12 = _rt::alloc::Layout::from_size_align_unchecked(
                            vec12.len() * 8,
                            4,
                        );
                        let result12 = if layout12.size() != 0 {
                            let ptr = _rt::alloc::alloc(layout12).cast::<u8>();
                            if ptr.is_null() {
                                _rt::alloc::handle_alloc_error(layout12);
                            }
                            ptr
                        } else {
                            ::core::ptr::null_mut()
                        };
                        for (i, e) in vec12.into_iter().enumerate() {
                            let base = result12.add(i * 8);
                            {
                                let WitValue { nodes: nodes1 } = e;
                                let vec11 = nodes1;
                                let len11 = vec11.len();
                                let layout11 = _rt::alloc::Layout::from_size_align_unchecked(
                                    vec11.len() * 24,
                                    8,
                                );
                                let result11 = if layout11.size() != 0 {
                                    let ptr = _rt::alloc::alloc(layout11).cast::<u8>();
                                    if ptr.is_null() {
                                        _rt::alloc::handle_alloc_error(layout11);
                                    }
                                    ptr
                                } else {
                                    ::core::ptr::null_mut()
                                };
                                for (i, e) in vec11.into_iter().enumerate() {
                                    let base = result11.add(i * 24);
                                    {
                                        match e {
                                            WitNode::RecordValue(e) => {
                                                *base.add(0).cast::<u8>() = (0i32) as u8;
                                                let vec2 = e;
                                                let ptr2 = vec2.as_ptr().cast::<u8>();
                                                let len2 = vec2.len();
                                                *base.add(12).cast::<usize>() = len2;
                                                *base.add(8).cast::<*mut u8>() = ptr2.cast_mut();
                                            }
                                            WitNode::VariantValue(e) => {
                                                *base.add(0).cast::<u8>() = (1i32) as u8;
                                                let (t3_0, t3_1) = e;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(t3_0);
                                                match t3_1 {
                                                    Some(e) => {
                                                        *base.add(12).cast::<u8>() = (1i32) as u8;
                                                        *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                    }
                                                    None => {
                                                        *base.add(12).cast::<u8>() = (0i32) as u8;
                                                    }
                                                };
                                            }
                                            WitNode::EnumValue(e) => {
                                                *base.add(0).cast::<u8>() = (2i32) as u8;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            WitNode::FlagsValue(e) => {
                                                *base.add(0).cast::<u8>() = (3i32) as u8;
                                                let vec4 = e;
                                                let len4 = vec4.len();
                                                let layout4 = _rt::alloc::Layout::from_size_align_unchecked(
                                                    vec4.len() * 1,
                                                    1,
                                                );
                                                let result4 = if layout4.size() != 0 {
                                                    let ptr = _rt::alloc::alloc(layout4).cast::<u8>();
                                                    if ptr.is_null() {
                                                        _rt::alloc::handle_alloc_error(layout4);
                                                    }
                                                    ptr
                                                } else {
                                                    ::core::ptr::null_mut()
                                                };
                                                for (i, e) in vec4.into_iter().enumerate() {
                                                    let base = result4.add(i * 1);
                                                    {
                                                        *base.add(0).cast::<u8>() = (match e {
                                                            true => 1,
                                                            false => 0,
                                                        }) as u8;
                                                    }
                                                }
                                                *base.add(12).cast::<usize>() = len4;
                                                *base.add(8).cast::<*mut u8>() = result4;
                                                cleanup_list.extend_from_slice(&[(result4, layout4)]);
                                            }
                                            WitNode::TupleValue(e) => {
                                                *base.add(0).cast::<u8>() = (4i32) as u8;
                                                let vec5 = e;
                                                let ptr5 = vec5.as_ptr().cast::<u8>();
                                                let len5 = vec5.len();
                                                *base.add(12).cast::<usize>() = len5;
                                                *base.add(8).cast::<*mut u8>() = ptr5.cast_mut();
                                            }
                                            WitNode::ListValue(e) => {
                                                *base.add(0).cast::<u8>() = (5i32) as u8;
                                                let vec6 = e;
                                                let ptr6 = vec6.as_ptr().cast::<u8>();
                                                let len6 = vec6.len();
                                                *base.add(12).cast::<usize>() = len6;
                                                *base.add(8).cast::<*mut u8>() = ptr6.cast_mut();
                                            }
                                            WitNode::OptionValue(e) => {
                                                *base.add(0).cast::<u8>() = (6i32) as u8;
                                                match e {
                                                    Some(e) => {
                                                        *base.add(8).cast::<u8>() = (1i32) as u8;
                                                        *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                                    }
                                                    None => {
                                                        *base.add(8).cast::<u8>() = (0i32) as u8;
                                                    }
                                                };
                                            }
                                            WitNode::ResultValue(e) => {
                                                *base.add(0).cast::<u8>() = (7i32) as u8;
                                                match e {
                                                    Ok(e) => {
                                                        *base.add(8).cast::<u8>() = (0i32) as u8;
                                                        match e {
                                                            Some(e) => {
                                                                *base.add(12).cast::<u8>() = (1i32) as u8;
                                                                *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                            }
                                                            None => {
                                                                *base.add(12).cast::<u8>() = (0i32) as u8;
                                                            }
                                                        };
                                                    }
                                                    Err(e) => {
                                                        *base.add(8).cast::<u8>() = (1i32) as u8;
                                                        match e {
                                                            Some(e) => {
                                                                *base.add(12).cast::<u8>() = (1i32) as u8;
                                                                *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                            }
                                                            None => {
                                                                *base.add(12).cast::<u8>() = (0i32) as u8;
                                                            }
                                                        };
                                                    }
                                                };
                                            }
                                            WitNode::PrimU8(e) => {
                                                *base.add(0).cast::<u8>() = (8i32) as u8;
                                                *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                            }
                                            WitNode::PrimU16(e) => {
                                                *base.add(0).cast::<u8>() = (9i32) as u8;
                                                *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                            }
                                            WitNode::PrimU32(e) => {
                                                *base.add(0).cast::<u8>() = (10i32) as u8;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            WitNode::PrimU64(e) => {
                                                *base.add(0).cast::<u8>() = (11i32) as u8;
                                                *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            WitNode::PrimS8(e) => {
                                                *base.add(0).cast::<u8>() = (12i32) as u8;
                                                *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                            }
                                            WitNode::PrimS16(e) => {
                                                *base.add(0).cast::<u8>() = (13i32) as u8;
                                                *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                            }
                                            WitNode::PrimS32(e) => {
                                                *base.add(0).cast::<u8>() = (14i32) as u8;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            WitNode::PrimS64(e) => {
                                                *base.add(0).cast::<u8>() = (15i32) as u8;
                                                *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            WitNode::PrimFloat32(e) => {
                                                *base.add(0).cast::<u8>() = (16i32) as u8;
                                                *base.add(8).cast::<f32>() = _rt::as_f32(e);
                                            }
                                            WitNode::PrimFloat64(e) => {
                                                *base.add(0).cast::<u8>() = (17i32) as u8;
                                                *base.add(8).cast::<f64>() = _rt::as_f64(e);
                                            }
                                            WitNode::PrimChar(e) => {
                                                *base.add(0).cast::<u8>() = (18i32) as u8;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            WitNode::PrimBool(e) => {
                                                *base.add(0).cast::<u8>() = (19i32) as u8;
                                                *base.add(8).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                            WitNode::PrimString(e) => {
                                                *base.add(0).cast::<u8>() = (20i32) as u8;
                                                let vec7 = e;
                                                let ptr7 = vec7.as_ptr().cast::<u8>();
                                                let len7 = vec7.len();
                                                *base.add(12).cast::<usize>() = len7;
                                                *base.add(8).cast::<*mut u8>() = ptr7.cast_mut();
                                            }
                                            WitNode::Handle(e) => {
                                                *base.add(0).cast::<u8>() = (21i32) as u8;
                                                let (t8_0, t8_1) = e;
                                                let Uri { value: value9 } = t8_0;
                                                let vec10 = value9;
                                                let ptr10 = vec10.as_ptr().cast::<u8>();
                                                let len10 = vec10.len();
                                                *base.add(12).cast::<usize>() = len10;
                                                *base.add(8).cast::<*mut u8>() = ptr10.cast_mut();
                                                *base.add(16).cast::<i64>() = _rt::as_i64(t8_1);
                                            }
                                        }
                                    }
                                }
                                *base.add(4).cast::<usize>() = len11;
                                *base.add(0).cast::<*mut u8>() = result11;
                                cleanup_list.extend_from_slice(&[(result11, layout11)]);
                            }
                        }
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rpc/types@0.1.3")]
                        extern "C" {
                            #[link_name = "[method]wasm-rpc.async-invoke-and-await"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                            ) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                        ) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            result12,
                            len12,
                        );
                        if layout12.size() != 0 {
                            _rt::alloc::dealloc(result12.cast(), layout12);
                        }
                        for (ptr, layout) in cleanup_list {
                            if layout.size() != 0 {
                                _rt::alloc::dealloc(ptr.cast(), layout);
                            }
                        }
                        FutureInvokeResult::from_handle(ret as u32)
                    }
                }
            }
            impl WasmRpc {
                #[allow(unused_unsafe, clippy::all)]
                /// Schedule invocation for later
                pub fn schedule_invocation(
                    &self,
                    scheduled_time: Datetime,
                    function_name: &str,
                    function_params: &[WitValue],
                ) {
                    unsafe {
                        let mut cleanup_list = _rt::Vec::new();
                        let super::super::super::wasi::clocks::wall_clock::Datetime {
                            seconds: seconds0,
                            nanoseconds: nanoseconds0,
                        } = scheduled_time;
                        let vec1 = function_name;
                        let ptr1 = vec1.as_ptr().cast::<u8>();
                        let len1 = vec1.len();
                        let vec13 = function_params;
                        let len13 = vec13.len();
                        let layout13 = _rt::alloc::Layout::from_size_align_unchecked(
                            vec13.len() * 8,
                            4,
                        );
                        let result13 = if layout13.size() != 0 {
                            let ptr = _rt::alloc::alloc(layout13).cast::<u8>();
                            if ptr.is_null() {
                                _rt::alloc::handle_alloc_error(layout13);
                            }
                            ptr
                        } else {
                            ::core::ptr::null_mut()
                        };
                        for (i, e) in vec13.into_iter().enumerate() {
                            let base = result13.add(i * 8);
                            {
                                let WitValue { nodes: nodes2 } = e;
                                let vec12 = nodes2;
                                let len12 = vec12.len();
                                let layout12 = _rt::alloc::Layout::from_size_align_unchecked(
                                    vec12.len() * 24,
                                    8,
                                );
                                let result12 = if layout12.size() != 0 {
                                    let ptr = _rt::alloc::alloc(layout12).cast::<u8>();
                                    if ptr.is_null() {
                                        _rt::alloc::handle_alloc_error(layout12);
                                    }
                                    ptr
                                } else {
                                    ::core::ptr::null_mut()
                                };
                                for (i, e) in vec12.into_iter().enumerate() {
                                    let base = result12.add(i * 24);
                                    {
                                        match e {
                                            WitNode::RecordValue(e) => {
                                                *base.add(0).cast::<u8>() = (0i32) as u8;
                                                let vec3 = e;
                                                let ptr3 = vec3.as_ptr().cast::<u8>();
                                                let len3 = vec3.len();
                                                *base.add(12).cast::<usize>() = len3;
                                                *base.add(8).cast::<*mut u8>() = ptr3.cast_mut();
                                            }
                                            WitNode::VariantValue(e) => {
                                                *base.add(0).cast::<u8>() = (1i32) as u8;
                                                let (t4_0, t4_1) = e;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(t4_0);
                                                match t4_1 {
                                                    Some(e) => {
                                                        *base.add(12).cast::<u8>() = (1i32) as u8;
                                                        *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                    }
                                                    None => {
                                                        *base.add(12).cast::<u8>() = (0i32) as u8;
                                                    }
                                                };
                                            }
                                            WitNode::EnumValue(e) => {
                                                *base.add(0).cast::<u8>() = (2i32) as u8;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            WitNode::FlagsValue(e) => {
                                                *base.add(0).cast::<u8>() = (3i32) as u8;
                                                let vec5 = e;
                                                let len5 = vec5.len();
                                                let layout5 = _rt::alloc::Layout::from_size_align_unchecked(
                                                    vec5.len() * 1,
                                                    1,
                                                );
                                                let result5 = if layout5.size() != 0 {
                                                    let ptr = _rt::alloc::alloc(layout5).cast::<u8>();
                                                    if ptr.is_null() {
                                                        _rt::alloc::handle_alloc_error(layout5);
                                                    }
                                                    ptr
                                                } else {
                                                    ::core::ptr::null_mut()
                                                };
                                                for (i, e) in vec5.into_iter().enumerate() {
                                                    let base = result5.add(i * 1);
                                                    {
                                                        *base.add(0).cast::<u8>() = (match e {
                                                            true => 1,
                                                            false => 0,
                                                        }) as u8;
                                                    }
                                                }
                                                *base.add(12).cast::<usize>() = len5;
                                                *base.add(8).cast::<*mut u8>() = result5;
                                                cleanup_list.extend_from_slice(&[(result5, layout5)]);
                                            }
                                            WitNode::TupleValue(e) => {
                                                *base.add(0).cast::<u8>() = (4i32) as u8;
                                                let vec6 = e;
                                                let ptr6 = vec6.as_ptr().cast::<u8>();
                                                let len6 = vec6.len();
                                                *base.add(12).cast::<usize>() = len6;
                                                *base.add(8).cast::<*mut u8>() = ptr6.cast_mut();
                                            }
                                            WitNode::ListValue(e) => {
                                                *base.add(0).cast::<u8>() = (5i32) as u8;
                                                let vec7 = e;
                                                let ptr7 = vec7.as_ptr().cast::<u8>();
                                                let len7 = vec7.len();
                                                *base.add(12).cast::<usize>() = len7;
                                                *base.add(8).cast::<*mut u8>() = ptr7.cast_mut();
                                            }
                                            WitNode::OptionValue(e) => {
                                                *base.add(0).cast::<u8>() = (6i32) as u8;
                                                match e {
                                                    Some(e) => {
                                                        *base.add(8).cast::<u8>() = (1i32) as u8;
                                                        *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                                    }
                                                    None => {
                                                        *base.add(8).cast::<u8>() = (0i32) as u8;
                                                    }
                                                };
                                            }
                                            WitNode::ResultValue(e) => {
                                                *base.add(0).cast::<u8>() = (7i32) as u8;
                                                match e {
                                                    Ok(e) => {
                                                        *base.add(8).cast::<u8>() = (0i32) as u8;
                                                        match e {
                                                            Some(e) => {
                                                                *base.add(12).cast::<u8>() = (1i32) as u8;
                                                                *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                            }
                                                            None => {
                                                                *base.add(12).cast::<u8>() = (0i32) as u8;
                                                            }
                                                        };
                                                    }
                                                    Err(e) => {
                                                        *base.add(8).cast::<u8>() = (1i32) as u8;
                                                        match e {
                                                            Some(e) => {
                                                                *base.add(12).cast::<u8>() = (1i32) as u8;
                                                                *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                            }
                                                            None => {
                                                                *base.add(12).cast::<u8>() = (0i32) as u8;
                                                            }
                                                        };
                                                    }
                                                };
                                            }
                                            WitNode::PrimU8(e) => {
                                                *base.add(0).cast::<u8>() = (8i32) as u8;
                                                *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                            }
                                            WitNode::PrimU16(e) => {
                                                *base.add(0).cast::<u8>() = (9i32) as u8;
                                                *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                            }
                                            WitNode::PrimU32(e) => {
                                                *base.add(0).cast::<u8>() = (10i32) as u8;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            WitNode::PrimU64(e) => {
                                                *base.add(0).cast::<u8>() = (11i32) as u8;
                                                *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            WitNode::PrimS8(e) => {
                                                *base.add(0).cast::<u8>() = (12i32) as u8;
                                                *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                            }
                                            WitNode::PrimS16(e) => {
                                                *base.add(0).cast::<u8>() = (13i32) as u8;
                                                *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                            }
                                            WitNode::PrimS32(e) => {
                                                *base.add(0).cast::<u8>() = (14i32) as u8;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            WitNode::PrimS64(e) => {
                                                *base.add(0).cast::<u8>() = (15i32) as u8;
                                                *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            WitNode::PrimFloat32(e) => {
                                                *base.add(0).cast::<u8>() = (16i32) as u8;
                                                *base.add(8).cast::<f32>() = _rt::as_f32(e);
                                            }
                                            WitNode::PrimFloat64(e) => {
                                                *base.add(0).cast::<u8>() = (17i32) as u8;
                                                *base.add(8).cast::<f64>() = _rt::as_f64(e);
                                            }
                                            WitNode::PrimChar(e) => {
                                                *base.add(0).cast::<u8>() = (18i32) as u8;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            WitNode::PrimBool(e) => {
                                                *base.add(0).cast::<u8>() = (19i32) as u8;
                                                *base.add(8).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                            WitNode::PrimString(e) => {
                                                *base.add(0).cast::<u8>() = (20i32) as u8;
                                                let vec8 = e;
                                                let ptr8 = vec8.as_ptr().cast::<u8>();
                                                let len8 = vec8.len();
                                                *base.add(12).cast::<usize>() = len8;
                                                *base.add(8).cast::<*mut u8>() = ptr8.cast_mut();
                                            }
                                            WitNode::Handle(e) => {
                                                *base.add(0).cast::<u8>() = (21i32) as u8;
                                                let (t9_0, t9_1) = e;
                                                let Uri { value: value10 } = t9_0;
                                                let vec11 = value10;
                                                let ptr11 = vec11.as_ptr().cast::<u8>();
                                                let len11 = vec11.len();
                                                *base.add(12).cast::<usize>() = len11;
                                                *base.add(8).cast::<*mut u8>() = ptr11.cast_mut();
                                                *base.add(16).cast::<i64>() = _rt::as_i64(t9_1);
                                            }
                                        }
                                    }
                                }
                                *base.add(4).cast::<usize>() = len12;
                                *base.add(0).cast::<*mut u8>() = result12;
                                cleanup_list.extend_from_slice(&[(result12, layout12)]);
                            }
                        }
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rpc/types@0.1.3")]
                        extern "C" {
                            #[link_name = "[method]wasm-rpc.schedule-invocation"]
                            fn wit_import(
                                _: i32,
                                _: i64,
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: i64,
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            _rt::as_i64(seconds0),
                            _rt::as_i32(nanoseconds0),
                            ptr1.cast_mut(),
                            len1,
                            result13,
                            len13,
                        );
                        if layout13.size() != 0 {
                            _rt::alloc::dealloc(result13.cast(), layout13);
                        }
                        for (ptr, layout) in cleanup_list {
                            if layout.size() != 0 {
                                _rt::alloc::dealloc(ptr.cast(), layout);
                            }
                        }
                    }
                }
            }
            impl WasmRpc {
                #[allow(unused_unsafe, clippy::all)]
                /// Schedule invocation for later. Call cancel on the returned resource to cancel the invocation before the scheduled time.
                pub fn schedule_cancelable_invocation(
                    &self,
                    scheduled_time: Datetime,
                    function_name: &str,
                    function_params: &[WitValue],
                ) -> CancellationToken {
                    unsafe {
                        let mut cleanup_list = _rt::Vec::new();
                        let super::super::super::wasi::clocks::wall_clock::Datetime {
                            seconds: seconds0,
                            nanoseconds: nanoseconds0,
                        } = scheduled_time;
                        let vec1 = function_name;
                        let ptr1 = vec1.as_ptr().cast::<u8>();
                        let len1 = vec1.len();
                        let vec13 = function_params;
                        let len13 = vec13.len();
                        let layout13 = _rt::alloc::Layout::from_size_align_unchecked(
                            vec13.len() * 8,
                            4,
                        );
                        let result13 = if layout13.size() != 0 {
                            let ptr = _rt::alloc::alloc(layout13).cast::<u8>();
                            if ptr.is_null() {
                                _rt::alloc::handle_alloc_error(layout13);
                            }
                            ptr
                        } else {
                            ::core::ptr::null_mut()
                        };
                        for (i, e) in vec13.into_iter().enumerate() {
                            let base = result13.add(i * 8);
                            {
                                let WitValue { nodes: nodes2 } = e;
                                let vec12 = nodes2;
                                let len12 = vec12.len();
                                let layout12 = _rt::alloc::Layout::from_size_align_unchecked(
                                    vec12.len() * 24,
                                    8,
                                );
                                let result12 = if layout12.size() != 0 {
                                    let ptr = _rt::alloc::alloc(layout12).cast::<u8>();
                                    if ptr.is_null() {
                                        _rt::alloc::handle_alloc_error(layout12);
                                    }
                                    ptr
                                } else {
                                    ::core::ptr::null_mut()
                                };
                                for (i, e) in vec12.into_iter().enumerate() {
                                    let base = result12.add(i * 24);
                                    {
                                        match e {
                                            WitNode::RecordValue(e) => {
                                                *base.add(0).cast::<u8>() = (0i32) as u8;
                                                let vec3 = e;
                                                let ptr3 = vec3.as_ptr().cast::<u8>();
                                                let len3 = vec3.len();
                                                *base.add(12).cast::<usize>() = len3;
                                                *base.add(8).cast::<*mut u8>() = ptr3.cast_mut();
                                            }
                                            WitNode::VariantValue(e) => {
                                                *base.add(0).cast::<u8>() = (1i32) as u8;
                                                let (t4_0, t4_1) = e;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(t4_0);
                                                match t4_1 {
                                                    Some(e) => {
                                                        *base.add(12).cast::<u8>() = (1i32) as u8;
                                                        *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                    }
                                                    None => {
                                                        *base.add(12).cast::<u8>() = (0i32) as u8;
                                                    }
                                                };
                                            }
                                            WitNode::EnumValue(e) => {
                                                *base.add(0).cast::<u8>() = (2i32) as u8;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            WitNode::FlagsValue(e) => {
                                                *base.add(0).cast::<u8>() = (3i32) as u8;
                                                let vec5 = e;
                                                let len5 = vec5.len();
                                                let layout5 = _rt::alloc::Layout::from_size_align_unchecked(
                                                    vec5.len() * 1,
                                                    1,
                                                );
                                                let result5 = if layout5.size() != 0 {
                                                    let ptr = _rt::alloc::alloc(layout5).cast::<u8>();
                                                    if ptr.is_null() {
                                                        _rt::alloc::handle_alloc_error(layout5);
                                                    }
                                                    ptr
                                                } else {
                                                    ::core::ptr::null_mut()
                                                };
                                                for (i, e) in vec5.into_iter().enumerate() {
                                                    let base = result5.add(i * 1);
                                                    {
                                                        *base.add(0).cast::<u8>() = (match e {
                                                            true => 1,
                                                            false => 0,
                                                        }) as u8;
                                                    }
                                                }
                                                *base.add(12).cast::<usize>() = len5;
                                                *base.add(8).cast::<*mut u8>() = result5;
                                                cleanup_list.extend_from_slice(&[(result5, layout5)]);
                                            }
                                            WitNode::TupleValue(e) => {
                                                *base.add(0).cast::<u8>() = (4i32) as u8;
                                                let vec6 = e;
                                                let ptr6 = vec6.as_ptr().cast::<u8>();
                                                let len6 = vec6.len();
                                                *base.add(12).cast::<usize>() = len6;
                                                *base.add(8).cast::<*mut u8>() = ptr6.cast_mut();
                                            }
                                            WitNode::ListValue(e) => {
                                                *base.add(0).cast::<u8>() = (5i32) as u8;
                                                let vec7 = e;
                                                let ptr7 = vec7.as_ptr().cast::<u8>();
                                                let len7 = vec7.len();
                                                *base.add(12).cast::<usize>() = len7;
                                                *base.add(8).cast::<*mut u8>() = ptr7.cast_mut();
                                            }
                                            WitNode::OptionValue(e) => {
                                                *base.add(0).cast::<u8>() = (6i32) as u8;
                                                match e {
                                                    Some(e) => {
                                                        *base.add(8).cast::<u8>() = (1i32) as u8;
                                                        *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                                    }
                                                    None => {
                                                        *base.add(8).cast::<u8>() = (0i32) as u8;
                                                    }
                                                };
                                            }
                                            WitNode::ResultValue(e) => {
                                                *base.add(0).cast::<u8>() = (7i32) as u8;
                                                match e {
                                                    Ok(e) => {
                                                        *base.add(8).cast::<u8>() = (0i32) as u8;
                                                        match e {
                                                            Some(e) => {
                                                                *base.add(12).cast::<u8>() = (1i32) as u8;
                                                                *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                            }
                                                            None => {
                                                                *base.add(12).cast::<u8>() = (0i32) as u8;
                                                            }
                                                        };
                                                    }
                                                    Err(e) => {
                                                        *base.add(8).cast::<u8>() = (1i32) as u8;
                                                        match e {
                                                            Some(e) => {
                                                                *base.add(12).cast::<u8>() = (1i32) as u8;
                                                                *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                            }
                                                            None => {
                                                                *base.add(12).cast::<u8>() = (0i32) as u8;
                                                            }
                                                        };
                                                    }
                                                };
                                            }
                                            WitNode::PrimU8(e) => {
                                                *base.add(0).cast::<u8>() = (8i32) as u8;
                                                *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                            }
                                            WitNode::PrimU16(e) => {
                                                *base.add(0).cast::<u8>() = (9i32) as u8;
                                                *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                            }
                                            WitNode::PrimU32(e) => {
                                                *base.add(0).cast::<u8>() = (10i32) as u8;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            WitNode::PrimU64(e) => {
                                                *base.add(0).cast::<u8>() = (11i32) as u8;
                                                *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            WitNode::PrimS8(e) => {
                                                *base.add(0).cast::<u8>() = (12i32) as u8;
                                                *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                            }
                                            WitNode::PrimS16(e) => {
                                                *base.add(0).cast::<u8>() = (13i32) as u8;
                                                *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                            }
                                            WitNode::PrimS32(e) => {
                                                *base.add(0).cast::<u8>() = (14i32) as u8;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            WitNode::PrimS64(e) => {
                                                *base.add(0).cast::<u8>() = (15i32) as u8;
                                                *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                            }
                                            WitNode::PrimFloat32(e) => {
                                                *base.add(0).cast::<u8>() = (16i32) as u8;
                                                *base.add(8).cast::<f32>() = _rt::as_f32(e);
                                            }
                                            WitNode::PrimFloat64(e) => {
                                                *base.add(0).cast::<u8>() = (17i32) as u8;
                                                *base.add(8).cast::<f64>() = _rt::as_f64(e);
                                            }
                                            WitNode::PrimChar(e) => {
                                                *base.add(0).cast::<u8>() = (18i32) as u8;
                                                *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                            }
                                            WitNode::PrimBool(e) => {
                                                *base.add(0).cast::<u8>() = (19i32) as u8;
                                                *base.add(8).cast::<u8>() = (match e {
                                                    true => 1,
                                                    false => 0,
                                                }) as u8;
                                            }
                                            WitNode::PrimString(e) => {
                                                *base.add(0).cast::<u8>() = (20i32) as u8;
                                                let vec8 = e;
                                                let ptr8 = vec8.as_ptr().cast::<u8>();
                                                let len8 = vec8.len();
                                                *base.add(12).cast::<usize>() = len8;
                                                *base.add(8).cast::<*mut u8>() = ptr8.cast_mut();
                                            }
                                            WitNode::Handle(e) => {
                                                *base.add(0).cast::<u8>() = (21i32) as u8;
                                                let (t9_0, t9_1) = e;
                                                let Uri { value: value10 } = t9_0;
                                                let vec11 = value10;
                                                let ptr11 = vec11.as_ptr().cast::<u8>();
                                                let len11 = vec11.len();
                                                *base.add(12).cast::<usize>() = len11;
                                                *base.add(8).cast::<*mut u8>() = ptr11.cast_mut();
                                                *base.add(16).cast::<i64>() = _rt::as_i64(t9_1);
                                            }
                                        }
                                    }
                                }
                                *base.add(4).cast::<usize>() = len12;
                                *base.add(0).cast::<*mut u8>() = result12;
                                cleanup_list.extend_from_slice(&[(result12, layout12)]);
                            }
                        }
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rpc/types@0.1.3")]
                        extern "C" {
                            #[link_name = "[method]wasm-rpc.schedule-cancelable-invocation"]
                            fn wit_import(
                                _: i32,
                                _: i64,
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                            ) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: i64,
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                        ) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import(
                            (self).handle() as i32,
                            _rt::as_i64(seconds0),
                            _rt::as_i32(nanoseconds0),
                            ptr1.cast_mut(),
                            len1,
                            result13,
                            len13,
                        );
                        if layout13.size() != 0 {
                            _rt::alloc::dealloc(result13.cast(), layout13);
                        }
                        for (ptr, layout) in cleanup_list {
                            if layout.size() != 0 {
                                _rt::alloc::dealloc(ptr.cast(), layout);
                            }
                        }
                        CancellationToken::from_handle(ret as u32)
                    }
                }
            }
            impl FutureInvokeResult {
                #[allow(unused_unsafe, clippy::all)]
                pub fn subscribe(&self) -> Pollable {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rpc/types@0.1.3")]
                        extern "C" {
                            #[link_name = "[method]future-invoke-result.subscribe"]
                            fn wit_import(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import((self).handle() as i32);
                        super::super::super::wasi::io::poll::Pollable::from_handle(
                            ret as u32,
                        )
                    }
                }
            }
            impl FutureInvokeResult {
                #[allow(unused_unsafe, clippy::all)]
                pub fn get(&self) -> Option<Result<WitValue, RpcError>> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 20]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 20],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rpc/types@0.1.3")]
                        extern "C" {
                            #[link_name = "[method]future-invoke-result.get"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(4).cast::<u8>());
                                    match l2 {
                                        0 => {
                                            let e = {
                                                let l3 = *ptr0.add(8).cast::<*mut u8>();
                                                let l4 = *ptr0.add(12).cast::<usize>();
                                                let base50 = l3;
                                                let len50 = l4;
                                                let mut result50 = _rt::Vec::with_capacity(len50);
                                                for i in 0..len50 {
                                                    let base = base50.add(i * 24);
                                                    let e50 = {
                                                        let l5 = i32::from(*base.add(0).cast::<u8>());
                                                        let v49 = match l5 {
                                                            0 => {
                                                                let e49 = {
                                                                    let l6 = *base.add(8).cast::<*mut u8>();
                                                                    let l7 = *base.add(12).cast::<usize>();
                                                                    let len8 = l7;
                                                                    _rt::Vec::from_raw_parts(l6.cast(), len8, len8)
                                                                };
                                                                WitNode::RecordValue(e49)
                                                            }
                                                            1 => {
                                                                let e49 = {
                                                                    let l9 = *base.add(8).cast::<i32>();
                                                                    let l10 = i32::from(*base.add(12).cast::<u8>());
                                                                    (
                                                                        l9 as u32,
                                                                        match l10 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l11 = *base.add(16).cast::<i32>();
                                                                                    l11
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        },
                                                                    )
                                                                };
                                                                WitNode::VariantValue(e49)
                                                            }
                                                            2 => {
                                                                let e49 = {
                                                                    let l12 = *base.add(8).cast::<i32>();
                                                                    l12 as u32
                                                                };
                                                                WitNode::EnumValue(e49)
                                                            }
                                                            3 => {
                                                                let e49 = {
                                                                    let l13 = *base.add(8).cast::<*mut u8>();
                                                                    let l14 = *base.add(12).cast::<usize>();
                                                                    let base16 = l13;
                                                                    let len16 = l14;
                                                                    let mut result16 = _rt::Vec::with_capacity(len16);
                                                                    for i in 0..len16 {
                                                                        let base = base16.add(i * 1);
                                                                        let e16 = {
                                                                            let l15 = i32::from(*base.add(0).cast::<u8>());
                                                                            _rt::bool_lift(l15 as u8)
                                                                        };
                                                                        result16.push(e16);
                                                                    }
                                                                    _rt::cabi_dealloc(base16, len16 * 1, 1);
                                                                    result16
                                                                };
                                                                WitNode::FlagsValue(e49)
                                                            }
                                                            4 => {
                                                                let e49 = {
                                                                    let l17 = *base.add(8).cast::<*mut u8>();
                                                                    let l18 = *base.add(12).cast::<usize>();
                                                                    let len19 = l18;
                                                                    _rt::Vec::from_raw_parts(l17.cast(), len19, len19)
                                                                };
                                                                WitNode::TupleValue(e49)
                                                            }
                                                            5 => {
                                                                let e49 = {
                                                                    let l20 = *base.add(8).cast::<*mut u8>();
                                                                    let l21 = *base.add(12).cast::<usize>();
                                                                    let len22 = l21;
                                                                    _rt::Vec::from_raw_parts(l20.cast(), len22, len22)
                                                                };
                                                                WitNode::ListValue(e49)
                                                            }
                                                            6 => {
                                                                let e49 = {
                                                                    let l23 = i32::from(*base.add(8).cast::<u8>());
                                                                    match l23 {
                                                                        0 => None,
                                                                        1 => {
                                                                            let e = {
                                                                                let l24 = *base.add(12).cast::<i32>();
                                                                                l24
                                                                            };
                                                                            Some(e)
                                                                        }
                                                                        _ => _rt::invalid_enum_discriminant(),
                                                                    }
                                                                };
                                                                WitNode::OptionValue(e49)
                                                            }
                                                            7 => {
                                                                let e49 = {
                                                                    let l25 = i32::from(*base.add(8).cast::<u8>());
                                                                    match l25 {
                                                                        0 => {
                                                                            let e = {
                                                                                let l26 = i32::from(*base.add(12).cast::<u8>());
                                                                                match l26 {
                                                                                    0 => None,
                                                                                    1 => {
                                                                                        let e = {
                                                                                            let l27 = *base.add(16).cast::<i32>();
                                                                                            l27
                                                                                        };
                                                                                        Some(e)
                                                                                    }
                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                }
                                                                            };
                                                                            Ok(e)
                                                                        }
                                                                        1 => {
                                                                            let e = {
                                                                                let l28 = i32::from(*base.add(12).cast::<u8>());
                                                                                match l28 {
                                                                                    0 => None,
                                                                                    1 => {
                                                                                        let e = {
                                                                                            let l29 = *base.add(16).cast::<i32>();
                                                                                            l29
                                                                                        };
                                                                                        Some(e)
                                                                                    }
                                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                                }
                                                                            };
                                                                            Err(e)
                                                                        }
                                                                        _ => _rt::invalid_enum_discriminant(),
                                                                    }
                                                                };
                                                                WitNode::ResultValue(e49)
                                                            }
                                                            8 => {
                                                                let e49 = {
                                                                    let l30 = i32::from(*base.add(8).cast::<u8>());
                                                                    l30 as u8
                                                                };
                                                                WitNode::PrimU8(e49)
                                                            }
                                                            9 => {
                                                                let e49 = {
                                                                    let l31 = i32::from(*base.add(8).cast::<u16>());
                                                                    l31 as u16
                                                                };
                                                                WitNode::PrimU16(e49)
                                                            }
                                                            10 => {
                                                                let e49 = {
                                                                    let l32 = *base.add(8).cast::<i32>();
                                                                    l32 as u32
                                                                };
                                                                WitNode::PrimU32(e49)
                                                            }
                                                            11 => {
                                                                let e49 = {
                                                                    let l33 = *base.add(8).cast::<i64>();
                                                                    l33 as u64
                                                                };
                                                                WitNode::PrimU64(e49)
                                                            }
                                                            12 => {
                                                                let e49 = {
                                                                    let l34 = i32::from(*base.add(8).cast::<i8>());
                                                                    l34 as i8
                                                                };
                                                                WitNode::PrimS8(e49)
                                                            }
                                                            13 => {
                                                                let e49 = {
                                                                    let l35 = i32::from(*base.add(8).cast::<i16>());
                                                                    l35 as i16
                                                                };
                                                                WitNode::PrimS16(e49)
                                                            }
                                                            14 => {
                                                                let e49 = {
                                                                    let l36 = *base.add(8).cast::<i32>();
                                                                    l36
                                                                };
                                                                WitNode::PrimS32(e49)
                                                            }
                                                            15 => {
                                                                let e49 = {
                                                                    let l37 = *base.add(8).cast::<i64>();
                                                                    l37
                                                                };
                                                                WitNode::PrimS64(e49)
                                                            }
                                                            16 => {
                                                                let e49 = {
                                                                    let l38 = *base.add(8).cast::<f32>();
                                                                    l38
                                                                };
                                                                WitNode::PrimFloat32(e49)
                                                            }
                                                            17 => {
                                                                let e49 = {
                                                                    let l39 = *base.add(8).cast::<f64>();
                                                                    l39
                                                                };
                                                                WitNode::PrimFloat64(e49)
                                                            }
                                                            18 => {
                                                                let e49 = {
                                                                    let l40 = *base.add(8).cast::<i32>();
                                                                    _rt::char_lift(l40 as u32)
                                                                };
                                                                WitNode::PrimChar(e49)
                                                            }
                                                            19 => {
                                                                let e49 = {
                                                                    let l41 = i32::from(*base.add(8).cast::<u8>());
                                                                    _rt::bool_lift(l41 as u8)
                                                                };
                                                                WitNode::PrimBool(e49)
                                                            }
                                                            20 => {
                                                                let e49 = {
                                                                    let l42 = *base.add(8).cast::<*mut u8>();
                                                                    let l43 = *base.add(12).cast::<usize>();
                                                                    let len44 = l43;
                                                                    let bytes44 = _rt::Vec::from_raw_parts(
                                                                        l42.cast(),
                                                                        len44,
                                                                        len44,
                                                                    );
                                                                    _rt::string_lift(bytes44)
                                                                };
                                                                WitNode::PrimString(e49)
                                                            }
                                                            n => {
                                                                debug_assert_eq!(n, 21, "invalid enum discriminant");
                                                                let e49 = {
                                                                    let l45 = *base.add(8).cast::<*mut u8>();
                                                                    let l46 = *base.add(12).cast::<usize>();
                                                                    let len47 = l46;
                                                                    let bytes47 = _rt::Vec::from_raw_parts(
                                                                        l45.cast(),
                                                                        len47,
                                                                        len47,
                                                                    );
                                                                    let l48 = *base.add(16).cast::<i64>();
                                                                    (
                                                                        Uri {
                                                                            value: _rt::string_lift(bytes47),
                                                                        },
                                                                        l48 as u64,
                                                                    )
                                                                };
                                                                WitNode::Handle(e49)
                                                            }
                                                        };
                                                        v49
                                                    };
                                                    result50.push(e50);
                                                }
                                                _rt::cabi_dealloc(base50, len50 * 24, 8);
                                                WitValue { nodes: result50 }
                                            };
                                            Ok(e)
                                        }
                                        1 => {
                                            let e = {
                                                let l51 = i32::from(*ptr0.add(8).cast::<u8>());
                                                let v64 = match l51 {
                                                    0 => {
                                                        let e64 = {
                                                            let l52 = *ptr0.add(12).cast::<*mut u8>();
                                                            let l53 = *ptr0.add(16).cast::<usize>();
                                                            let len54 = l53;
                                                            let bytes54 = _rt::Vec::from_raw_parts(
                                                                l52.cast(),
                                                                len54,
                                                                len54,
                                                            );
                                                            _rt::string_lift(bytes54)
                                                        };
                                                        RpcError::ProtocolError(e64)
                                                    }
                                                    1 => {
                                                        let e64 = {
                                                            let l55 = *ptr0.add(12).cast::<*mut u8>();
                                                            let l56 = *ptr0.add(16).cast::<usize>();
                                                            let len57 = l56;
                                                            let bytes57 = _rt::Vec::from_raw_parts(
                                                                l55.cast(),
                                                                len57,
                                                                len57,
                                                            );
                                                            _rt::string_lift(bytes57)
                                                        };
                                                        RpcError::Denied(e64)
                                                    }
                                                    2 => {
                                                        let e64 = {
                                                            let l58 = *ptr0.add(12).cast::<*mut u8>();
                                                            let l59 = *ptr0.add(16).cast::<usize>();
                                                            let len60 = l59;
                                                            let bytes60 = _rt::Vec::from_raw_parts(
                                                                l58.cast(),
                                                                len60,
                                                                len60,
                                                            );
                                                            _rt::string_lift(bytes60)
                                                        };
                                                        RpcError::NotFound(e64)
                                                    }
                                                    n => {
                                                        debug_assert_eq!(n, 3, "invalid enum discriminant");
                                                        let e64 = {
                                                            let l61 = *ptr0.add(12).cast::<*mut u8>();
                                                            let l62 = *ptr0.add(16).cast::<usize>();
                                                            let len63 = l62;
                                                            let bytes63 = _rt::Vec::from_raw_parts(
                                                                l61.cast(),
                                                                len63,
                                                                len63,
                                                            );
                                                            _rt::string_lift(bytes63)
                                                        };
                                                        RpcError::RemoteInternalError(e64)
                                                    }
                                                };
                                                v64
                                            };
                                            Err(e)
                                        }
                                        _ => _rt::invalid_enum_discriminant(),
                                    }
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl CancellationToken {
                #[allow(unused_unsafe, clippy::all)]
                pub fn cancel(&self) {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "golem:rpc/types@0.1.3")]
                        extern "C" {
                            #[link_name = "[method]cancellation-token.cancel"]
                            fn wit_import(_: i32);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32);
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            pub fn extract_value(vnt: &ValueAndType) -> WitValue {
                unsafe {
                    let mut cleanup_list = _rt::Vec::new();
                    #[repr(align(4))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]);
                    let ValueAndType { value: value0, typ: typ0 } = vnt;
                    let WitValue { nodes: nodes1 } = value0;
                    let vec11 = nodes1;
                    let len11 = vec11.len();
                    let layout11 = _rt::alloc::Layout::from_size_align_unchecked(
                        vec11.len() * 24,
                        8,
                    );
                    let result11 = if layout11.size() != 0 {
                        let ptr = _rt::alloc::alloc(layout11).cast::<u8>();
                        if ptr.is_null() {
                            _rt::alloc::handle_alloc_error(layout11);
                        }
                        ptr
                    } else {
                        ::core::ptr::null_mut()
                    };
                    for (i, e) in vec11.into_iter().enumerate() {
                        let base = result11.add(i * 24);
                        {
                            match e {
                                WitNode::RecordValue(e) => {
                                    *base.add(0).cast::<u8>() = (0i32) as u8;
                                    let vec2 = e;
                                    let ptr2 = vec2.as_ptr().cast::<u8>();
                                    let len2 = vec2.len();
                                    *base.add(12).cast::<usize>() = len2;
                                    *base.add(8).cast::<*mut u8>() = ptr2.cast_mut();
                                }
                                WitNode::VariantValue(e) => {
                                    *base.add(0).cast::<u8>() = (1i32) as u8;
                                    let (t3_0, t3_1) = e;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(t3_0);
                                    match t3_1 {
                                        Some(e) => {
                                            *base.add(12).cast::<u8>() = (1i32) as u8;
                                            *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                        }
                                        None => {
                                            *base.add(12).cast::<u8>() = (0i32) as u8;
                                        }
                                    };
                                }
                                WitNode::EnumValue(e) => {
                                    *base.add(0).cast::<u8>() = (2i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                WitNode::FlagsValue(e) => {
                                    *base.add(0).cast::<u8>() = (3i32) as u8;
                                    let vec4 = e;
                                    let len4 = vec4.len();
                                    let layout4 = _rt::alloc::Layout::from_size_align_unchecked(
                                        vec4.len() * 1,
                                        1,
                                    );
                                    let result4 = if layout4.size() != 0 {
                                        let ptr = _rt::alloc::alloc(layout4).cast::<u8>();
                                        if ptr.is_null() {
                                            _rt::alloc::handle_alloc_error(layout4);
                                        }
                                        ptr
                                    } else {
                                        ::core::ptr::null_mut()
                                    };
                                    for (i, e) in vec4.into_iter().enumerate() {
                                        let base = result4.add(i * 1);
                                        {
                                            *base.add(0).cast::<u8>() = (match e {
                                                true => 1,
                                                false => 0,
                                            }) as u8;
                                        }
                                    }
                                    *base.add(12).cast::<usize>() = len4;
                                    *base.add(8).cast::<*mut u8>() = result4;
                                    cleanup_list.extend_from_slice(&[(result4, layout4)]);
                                }
                                WitNode::TupleValue(e) => {
                                    *base.add(0).cast::<u8>() = (4i32) as u8;
                                    let vec5 = e;
                                    let ptr5 = vec5.as_ptr().cast::<u8>();
                                    let len5 = vec5.len();
                                    *base.add(12).cast::<usize>() = len5;
                                    *base.add(8).cast::<*mut u8>() = ptr5.cast_mut();
                                }
                                WitNode::ListValue(e) => {
                                    *base.add(0).cast::<u8>() = (5i32) as u8;
                                    let vec6 = e;
                                    let ptr6 = vec6.as_ptr().cast::<u8>();
                                    let len6 = vec6.len();
                                    *base.add(12).cast::<usize>() = len6;
                                    *base.add(8).cast::<*mut u8>() = ptr6.cast_mut();
                                }
                                WitNode::OptionValue(e) => {
                                    *base.add(0).cast::<u8>() = (6i32) as u8;
                                    match e {
                                        Some(e) => {
                                            *base.add(8).cast::<u8>() = (1i32) as u8;
                                            *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                        }
                                        None => {
                                            *base.add(8).cast::<u8>() = (0i32) as u8;
                                        }
                                    };
                                }
                                WitNode::ResultValue(e) => {
                                    *base.add(0).cast::<u8>() = (7i32) as u8;
                                    match e {
                                        Ok(e) => {
                                            *base.add(8).cast::<u8>() = (0i32) as u8;
                                            match e {
                                                Some(e) => {
                                                    *base.add(12).cast::<u8>() = (1i32) as u8;
                                                    *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                }
                                                None => {
                                                    *base.add(12).cast::<u8>() = (0i32) as u8;
                                                }
                                            };
                                        }
                                        Err(e) => {
                                            *base.add(8).cast::<u8>() = (1i32) as u8;
                                            match e {
                                                Some(e) => {
                                                    *base.add(12).cast::<u8>() = (1i32) as u8;
                                                    *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                }
                                                None => {
                                                    *base.add(12).cast::<u8>() = (0i32) as u8;
                                                }
                                            };
                                        }
                                    };
                                }
                                WitNode::PrimU8(e) => {
                                    *base.add(0).cast::<u8>() = (8i32) as u8;
                                    *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                }
                                WitNode::PrimU16(e) => {
                                    *base.add(0).cast::<u8>() = (9i32) as u8;
                                    *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                }
                                WitNode::PrimU32(e) => {
                                    *base.add(0).cast::<u8>() = (10i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                WitNode::PrimU64(e) => {
                                    *base.add(0).cast::<u8>() = (11i32) as u8;
                                    *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                }
                                WitNode::PrimS8(e) => {
                                    *base.add(0).cast::<u8>() = (12i32) as u8;
                                    *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                }
                                WitNode::PrimS16(e) => {
                                    *base.add(0).cast::<u8>() = (13i32) as u8;
                                    *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                }
                                WitNode::PrimS32(e) => {
                                    *base.add(0).cast::<u8>() = (14i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                WitNode::PrimS64(e) => {
                                    *base.add(0).cast::<u8>() = (15i32) as u8;
                                    *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                }
                                WitNode::PrimFloat32(e) => {
                                    *base.add(0).cast::<u8>() = (16i32) as u8;
                                    *base.add(8).cast::<f32>() = _rt::as_f32(e);
                                }
                                WitNode::PrimFloat64(e) => {
                                    *base.add(0).cast::<u8>() = (17i32) as u8;
                                    *base.add(8).cast::<f64>() = _rt::as_f64(e);
                                }
                                WitNode::PrimChar(e) => {
                                    *base.add(0).cast::<u8>() = (18i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                WitNode::PrimBool(e) => {
                                    *base.add(0).cast::<u8>() = (19i32) as u8;
                                    *base.add(8).cast::<u8>() = (match e {
                                        true => 1,
                                        false => 0,
                                    }) as u8;
                                }
                                WitNode::PrimString(e) => {
                                    *base.add(0).cast::<u8>() = (20i32) as u8;
                                    let vec7 = e;
                                    let ptr7 = vec7.as_ptr().cast::<u8>();
                                    let len7 = vec7.len();
                                    *base.add(12).cast::<usize>() = len7;
                                    *base.add(8).cast::<*mut u8>() = ptr7.cast_mut();
                                }
                                WitNode::Handle(e) => {
                                    *base.add(0).cast::<u8>() = (21i32) as u8;
                                    let (t8_0, t8_1) = e;
                                    let Uri { value: value9 } = t8_0;
                                    let vec10 = value9;
                                    let ptr10 = vec10.as_ptr().cast::<u8>();
                                    let len10 = vec10.len();
                                    *base.add(12).cast::<usize>() = len10;
                                    *base.add(8).cast::<*mut u8>() = ptr10.cast_mut();
                                    *base.add(16).cast::<i64>() = _rt::as_i64(t8_1);
                                }
                            }
                        }
                    }
                    let WitType { nodes: nodes12 } = typ0;
                    let vec26 = nodes12;
                    let len26 = vec26.len();
                    let layout26 = _rt::alloc::Layout::from_size_align_unchecked(
                        vec26.len() * 24,
                        8,
                    );
                    let result26 = if layout26.size() != 0 {
                        let ptr = _rt::alloc::alloc(layout26).cast::<u8>();
                        if ptr.is_null() {
                            _rt::alloc::handle_alloc_error(layout26);
                        }
                        ptr
                    } else {
                        ::core::ptr::null_mut()
                    };
                    for (i, e) in vec26.into_iter().enumerate() {
                        let base = result26.add(i * 24);
                        {
                            match e {
                                WitTypeNode::RecordType(e) => {
                                    *base.add(0).cast::<u8>() = (0i32) as u8;
                                    let vec15 = e;
                                    let len15 = vec15.len();
                                    let layout15 = _rt::alloc::Layout::from_size_align_unchecked(
                                        vec15.len() * 12,
                                        4,
                                    );
                                    let result15 = if layout15.size() != 0 {
                                        let ptr = _rt::alloc::alloc(layout15).cast::<u8>();
                                        if ptr.is_null() {
                                            _rt::alloc::handle_alloc_error(layout15);
                                        }
                                        ptr
                                    } else {
                                        ::core::ptr::null_mut()
                                    };
                                    for (i, e) in vec15.into_iter().enumerate() {
                                        let base = result15.add(i * 12);
                                        {
                                            let (t13_0, t13_1) = e;
                                            let vec14 = t13_0;
                                            let ptr14 = vec14.as_ptr().cast::<u8>();
                                            let len14 = vec14.len();
                                            *base.add(4).cast::<usize>() = len14;
                                            *base.add(0).cast::<*mut u8>() = ptr14.cast_mut();
                                            *base.add(8).cast::<i32>() = _rt::as_i32(t13_1);
                                        }
                                    }
                                    *base.add(12).cast::<usize>() = len15;
                                    *base.add(8).cast::<*mut u8>() = result15;
                                    cleanup_list.extend_from_slice(&[(result15, layout15)]);
                                }
                                WitTypeNode::VariantType(e) => {
                                    *base.add(0).cast::<u8>() = (1i32) as u8;
                                    let vec18 = e;
                                    let len18 = vec18.len();
                                    let layout18 = _rt::alloc::Layout::from_size_align_unchecked(
                                        vec18.len() * 16,
                                        4,
                                    );
                                    let result18 = if layout18.size() != 0 {
                                        let ptr = _rt::alloc::alloc(layout18).cast::<u8>();
                                        if ptr.is_null() {
                                            _rt::alloc::handle_alloc_error(layout18);
                                        }
                                        ptr
                                    } else {
                                        ::core::ptr::null_mut()
                                    };
                                    for (i, e) in vec18.into_iter().enumerate() {
                                        let base = result18.add(i * 16);
                                        {
                                            let (t16_0, t16_1) = e;
                                            let vec17 = t16_0;
                                            let ptr17 = vec17.as_ptr().cast::<u8>();
                                            let len17 = vec17.len();
                                            *base.add(4).cast::<usize>() = len17;
                                            *base.add(0).cast::<*mut u8>() = ptr17.cast_mut();
                                            match t16_1 {
                                                Some(e) => {
                                                    *base.add(8).cast::<u8>() = (1i32) as u8;
                                                    *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                                }
                                                None => {
                                                    *base.add(8).cast::<u8>() = (0i32) as u8;
                                                }
                                            };
                                        }
                                    }
                                    *base.add(12).cast::<usize>() = len18;
                                    *base.add(8).cast::<*mut u8>() = result18;
                                    cleanup_list.extend_from_slice(&[(result18, layout18)]);
                                }
                                WitTypeNode::EnumType(e) => {
                                    *base.add(0).cast::<u8>() = (2i32) as u8;
                                    let vec20 = e;
                                    let len20 = vec20.len();
                                    let layout20 = _rt::alloc::Layout::from_size_align_unchecked(
                                        vec20.len() * 8,
                                        4,
                                    );
                                    let result20 = if layout20.size() != 0 {
                                        let ptr = _rt::alloc::alloc(layout20).cast::<u8>();
                                        if ptr.is_null() {
                                            _rt::alloc::handle_alloc_error(layout20);
                                        }
                                        ptr
                                    } else {
                                        ::core::ptr::null_mut()
                                    };
                                    for (i, e) in vec20.into_iter().enumerate() {
                                        let base = result20.add(i * 8);
                                        {
                                            let vec19 = e;
                                            let ptr19 = vec19.as_ptr().cast::<u8>();
                                            let len19 = vec19.len();
                                            *base.add(4).cast::<usize>() = len19;
                                            *base.add(0).cast::<*mut u8>() = ptr19.cast_mut();
                                        }
                                    }
                                    *base.add(12).cast::<usize>() = len20;
                                    *base.add(8).cast::<*mut u8>() = result20;
                                    cleanup_list.extend_from_slice(&[(result20, layout20)]);
                                }
                                WitTypeNode::FlagsType(e) => {
                                    *base.add(0).cast::<u8>() = (3i32) as u8;
                                    let vec22 = e;
                                    let len22 = vec22.len();
                                    let layout22 = _rt::alloc::Layout::from_size_align_unchecked(
                                        vec22.len() * 8,
                                        4,
                                    );
                                    let result22 = if layout22.size() != 0 {
                                        let ptr = _rt::alloc::alloc(layout22).cast::<u8>();
                                        if ptr.is_null() {
                                            _rt::alloc::handle_alloc_error(layout22);
                                        }
                                        ptr
                                    } else {
                                        ::core::ptr::null_mut()
                                    };
                                    for (i, e) in vec22.into_iter().enumerate() {
                                        let base = result22.add(i * 8);
                                        {
                                            let vec21 = e;
                                            let ptr21 = vec21.as_ptr().cast::<u8>();
                                            let len21 = vec21.len();
                                            *base.add(4).cast::<usize>() = len21;
                                            *base.add(0).cast::<*mut u8>() = ptr21.cast_mut();
                                        }
                                    }
                                    *base.add(12).cast::<usize>() = len22;
                                    *base.add(8).cast::<*mut u8>() = result22;
                                    cleanup_list.extend_from_slice(&[(result22, layout22)]);
                                }
                                WitTypeNode::TupleType(e) => {
                                    *base.add(0).cast::<u8>() = (4i32) as u8;
                                    let vec23 = e;
                                    let ptr23 = vec23.as_ptr().cast::<u8>();
                                    let len23 = vec23.len();
                                    *base.add(12).cast::<usize>() = len23;
                                    *base.add(8).cast::<*mut u8>() = ptr23.cast_mut();
                                }
                                WitTypeNode::ListType(e) => {
                                    *base.add(0).cast::<u8>() = (5i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                WitTypeNode::OptionType(e) => {
                                    *base.add(0).cast::<u8>() = (6i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                WitTypeNode::ResultType(e) => {
                                    *base.add(0).cast::<u8>() = (7i32) as u8;
                                    let (t24_0, t24_1) = e;
                                    match t24_0 {
                                        Some(e) => {
                                            *base.add(8).cast::<u8>() = (1i32) as u8;
                                            *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                        }
                                        None => {
                                            *base.add(8).cast::<u8>() = (0i32) as u8;
                                        }
                                    };
                                    match t24_1 {
                                        Some(e) => {
                                            *base.add(16).cast::<u8>() = (1i32) as u8;
                                            *base.add(20).cast::<i32>() = _rt::as_i32(e);
                                        }
                                        None => {
                                            *base.add(16).cast::<u8>() = (0i32) as u8;
                                        }
                                    };
                                }
                                WitTypeNode::PrimU8Type => {
                                    *base.add(0).cast::<u8>() = (8i32) as u8;
                                }
                                WitTypeNode::PrimU16Type => {
                                    *base.add(0).cast::<u8>() = (9i32) as u8;
                                }
                                WitTypeNode::PrimU32Type => {
                                    *base.add(0).cast::<u8>() = (10i32) as u8;
                                }
                                WitTypeNode::PrimU64Type => {
                                    *base.add(0).cast::<u8>() = (11i32) as u8;
                                }
                                WitTypeNode::PrimS8Type => {
                                    *base.add(0).cast::<u8>() = (12i32) as u8;
                                }
                                WitTypeNode::PrimS16Type => {
                                    *base.add(0).cast::<u8>() = (13i32) as u8;
                                }
                                WitTypeNode::PrimS32Type => {
                                    *base.add(0).cast::<u8>() = (14i32) as u8;
                                }
                                WitTypeNode::PrimS64Type => {
                                    *base.add(0).cast::<u8>() = (15i32) as u8;
                                }
                                WitTypeNode::PrimF32Type => {
                                    *base.add(0).cast::<u8>() = (16i32) as u8;
                                }
                                WitTypeNode::PrimF64Type => {
                                    *base.add(0).cast::<u8>() = (17i32) as u8;
                                }
                                WitTypeNode::PrimCharType => {
                                    *base.add(0).cast::<u8>() = (18i32) as u8;
                                }
                                WitTypeNode::PrimBoolType => {
                                    *base.add(0).cast::<u8>() = (19i32) as u8;
                                }
                                WitTypeNode::PrimStringType => {
                                    *base.add(0).cast::<u8>() = (20i32) as u8;
                                }
                                WitTypeNode::HandleType(e) => {
                                    *base.add(0).cast::<u8>() = (21i32) as u8;
                                    let (t25_0, t25_1) = e;
                                    *base.add(8).cast::<i64>() = _rt::as_i64(t25_0);
                                    *base.add(16).cast::<u8>() = (t25_1.clone() as i32) as u8;
                                }
                            }
                        }
                    }
                    let ptr27 = ret_area.0.as_mut_ptr().cast::<u8>();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:rpc/types@0.1.3")]
                    extern "C" {
                        #[link_name = "extract-value"]
                        fn wit_import(
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        );
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                    ) {
                        unreachable!()
                    }
                    wit_import(result11, len11, result26, len26, ptr27);
                    let l28 = *ptr27.add(0).cast::<*mut u8>();
                    let l29 = *ptr27.add(4).cast::<usize>();
                    let base75 = l28;
                    let len75 = l29;
                    let mut result75 = _rt::Vec::with_capacity(len75);
                    for i in 0..len75 {
                        let base = base75.add(i * 24);
                        let e75 = {
                            let l30 = i32::from(*base.add(0).cast::<u8>());
                            let v74 = match l30 {
                                0 => {
                                    let e74 = {
                                        let l31 = *base.add(8).cast::<*mut u8>();
                                        let l32 = *base.add(12).cast::<usize>();
                                        let len33 = l32;
                                        _rt::Vec::from_raw_parts(l31.cast(), len33, len33)
                                    };
                                    WitNode::RecordValue(e74)
                                }
                                1 => {
                                    let e74 = {
                                        let l34 = *base.add(8).cast::<i32>();
                                        let l35 = i32::from(*base.add(12).cast::<u8>());
                                        (
                                            l34 as u32,
                                            match l35 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l36 = *base.add(16).cast::<i32>();
                                                        l36
                                                    };
                                                    Some(e)
                                                }
                                                _ => _rt::invalid_enum_discriminant(),
                                            },
                                        )
                                    };
                                    WitNode::VariantValue(e74)
                                }
                                2 => {
                                    let e74 = {
                                        let l37 = *base.add(8).cast::<i32>();
                                        l37 as u32
                                    };
                                    WitNode::EnumValue(e74)
                                }
                                3 => {
                                    let e74 = {
                                        let l38 = *base.add(8).cast::<*mut u8>();
                                        let l39 = *base.add(12).cast::<usize>();
                                        let base41 = l38;
                                        let len41 = l39;
                                        let mut result41 = _rt::Vec::with_capacity(len41);
                                        for i in 0..len41 {
                                            let base = base41.add(i * 1);
                                            let e41 = {
                                                let l40 = i32::from(*base.add(0).cast::<u8>());
                                                _rt::bool_lift(l40 as u8)
                                            };
                                            result41.push(e41);
                                        }
                                        _rt::cabi_dealloc(base41, len41 * 1, 1);
                                        result41
                                    };
                                    WitNode::FlagsValue(e74)
                                }
                                4 => {
                                    let e74 = {
                                        let l42 = *base.add(8).cast::<*mut u8>();
                                        let l43 = *base.add(12).cast::<usize>();
                                        let len44 = l43;
                                        _rt::Vec::from_raw_parts(l42.cast(), len44, len44)
                                    };
                                    WitNode::TupleValue(e74)
                                }
                                5 => {
                                    let e74 = {
                                        let l45 = *base.add(8).cast::<*mut u8>();
                                        let l46 = *base.add(12).cast::<usize>();
                                        let len47 = l46;
                                        _rt::Vec::from_raw_parts(l45.cast(), len47, len47)
                                    };
                                    WitNode::ListValue(e74)
                                }
                                6 => {
                                    let e74 = {
                                        let l48 = i32::from(*base.add(8).cast::<u8>());
                                        match l48 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l49 = *base.add(12).cast::<i32>();
                                                    l49
                                                };
                                                Some(e)
                                            }
                                            _ => _rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    WitNode::OptionValue(e74)
                                }
                                7 => {
                                    let e74 = {
                                        let l50 = i32::from(*base.add(8).cast::<u8>());
                                        match l50 {
                                            0 => {
                                                let e = {
                                                    let l51 = i32::from(*base.add(12).cast::<u8>());
                                                    match l51 {
                                                        0 => None,
                                                        1 => {
                                                            let e = {
                                                                let l52 = *base.add(16).cast::<i32>();
                                                                l52
                                                            };
                                                            Some(e)
                                                        }
                                                        _ => _rt::invalid_enum_discriminant(),
                                                    }
                                                };
                                                Ok(e)
                                            }
                                            1 => {
                                                let e = {
                                                    let l53 = i32::from(*base.add(12).cast::<u8>());
                                                    match l53 {
                                                        0 => None,
                                                        1 => {
                                                            let e = {
                                                                let l54 = *base.add(16).cast::<i32>();
                                                                l54
                                                            };
                                                            Some(e)
                                                        }
                                                        _ => _rt::invalid_enum_discriminant(),
                                                    }
                                                };
                                                Err(e)
                                            }
                                            _ => _rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    WitNode::ResultValue(e74)
                                }
                                8 => {
                                    let e74 = {
                                        let l55 = i32::from(*base.add(8).cast::<u8>());
                                        l55 as u8
                                    };
                                    WitNode::PrimU8(e74)
                                }
                                9 => {
                                    let e74 = {
                                        let l56 = i32::from(*base.add(8).cast::<u16>());
                                        l56 as u16
                                    };
                                    WitNode::PrimU16(e74)
                                }
                                10 => {
                                    let e74 = {
                                        let l57 = *base.add(8).cast::<i32>();
                                        l57 as u32
                                    };
                                    WitNode::PrimU32(e74)
                                }
                                11 => {
                                    let e74 = {
                                        let l58 = *base.add(8).cast::<i64>();
                                        l58 as u64
                                    };
                                    WitNode::PrimU64(e74)
                                }
                                12 => {
                                    let e74 = {
                                        let l59 = i32::from(*base.add(8).cast::<i8>());
                                        l59 as i8
                                    };
                                    WitNode::PrimS8(e74)
                                }
                                13 => {
                                    let e74 = {
                                        let l60 = i32::from(*base.add(8).cast::<i16>());
                                        l60 as i16
                                    };
                                    WitNode::PrimS16(e74)
                                }
                                14 => {
                                    let e74 = {
                                        let l61 = *base.add(8).cast::<i32>();
                                        l61
                                    };
                                    WitNode::PrimS32(e74)
                                }
                                15 => {
                                    let e74 = {
                                        let l62 = *base.add(8).cast::<i64>();
                                        l62
                                    };
                                    WitNode::PrimS64(e74)
                                }
                                16 => {
                                    let e74 = {
                                        let l63 = *base.add(8).cast::<f32>();
                                        l63
                                    };
                                    WitNode::PrimFloat32(e74)
                                }
                                17 => {
                                    let e74 = {
                                        let l64 = *base.add(8).cast::<f64>();
                                        l64
                                    };
                                    WitNode::PrimFloat64(e74)
                                }
                                18 => {
                                    let e74 = {
                                        let l65 = *base.add(8).cast::<i32>();
                                        _rt::char_lift(l65 as u32)
                                    };
                                    WitNode::PrimChar(e74)
                                }
                                19 => {
                                    let e74 = {
                                        let l66 = i32::from(*base.add(8).cast::<u8>());
                                        _rt::bool_lift(l66 as u8)
                                    };
                                    WitNode::PrimBool(e74)
                                }
                                20 => {
                                    let e74 = {
                                        let l67 = *base.add(8).cast::<*mut u8>();
                                        let l68 = *base.add(12).cast::<usize>();
                                        let len69 = l68;
                                        let bytes69 = _rt::Vec::from_raw_parts(
                                            l67.cast(),
                                            len69,
                                            len69,
                                        );
                                        _rt::string_lift(bytes69)
                                    };
                                    WitNode::PrimString(e74)
                                }
                                n => {
                                    debug_assert_eq!(n, 21, "invalid enum discriminant");
                                    let e74 = {
                                        let l70 = *base.add(8).cast::<*mut u8>();
                                        let l71 = *base.add(12).cast::<usize>();
                                        let len72 = l71;
                                        let bytes72 = _rt::Vec::from_raw_parts(
                                            l70.cast(),
                                            len72,
                                            len72,
                                        );
                                        let l73 = *base.add(16).cast::<i64>();
                                        (
                                            Uri {
                                                value: _rt::string_lift(bytes72),
                                            },
                                            l73 as u64,
                                        )
                                    };
                                    WitNode::Handle(e74)
                                }
                            };
                            v74
                        };
                        result75.push(e75);
                    }
                    _rt::cabi_dealloc(base75, len75 * 24, 8);
                    if layout11.size() != 0 {
                        _rt::alloc::dealloc(result11.cast(), layout11);
                    }
                    if layout26.size() != 0 {
                        _rt::alloc::dealloc(result26.cast(), layout26);
                    }
                    for (ptr, layout) in cleanup_list {
                        if layout.size() != 0 {
                            _rt::alloc::dealloc(ptr.cast(), layout);
                        }
                    }
                    WitValue { nodes: result75 }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            pub fn extract_type(vnt: &ValueAndType) -> WitType {
                unsafe {
                    let mut cleanup_list = _rt::Vec::new();
                    #[repr(align(4))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]);
                    let ValueAndType { value: value0, typ: typ0 } = vnt;
                    let WitValue { nodes: nodes1 } = value0;
                    let vec11 = nodes1;
                    let len11 = vec11.len();
                    let layout11 = _rt::alloc::Layout::from_size_align_unchecked(
                        vec11.len() * 24,
                        8,
                    );
                    let result11 = if layout11.size() != 0 {
                        let ptr = _rt::alloc::alloc(layout11).cast::<u8>();
                        if ptr.is_null() {
                            _rt::alloc::handle_alloc_error(layout11);
                        }
                        ptr
                    } else {
                        ::core::ptr::null_mut()
                    };
                    for (i, e) in vec11.into_iter().enumerate() {
                        let base = result11.add(i * 24);
                        {
                            match e {
                                WitNode::RecordValue(e) => {
                                    *base.add(0).cast::<u8>() = (0i32) as u8;
                                    let vec2 = e;
                                    let ptr2 = vec2.as_ptr().cast::<u8>();
                                    let len2 = vec2.len();
                                    *base.add(12).cast::<usize>() = len2;
                                    *base.add(8).cast::<*mut u8>() = ptr2.cast_mut();
                                }
                                WitNode::VariantValue(e) => {
                                    *base.add(0).cast::<u8>() = (1i32) as u8;
                                    let (t3_0, t3_1) = e;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(t3_0);
                                    match t3_1 {
                                        Some(e) => {
                                            *base.add(12).cast::<u8>() = (1i32) as u8;
                                            *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                        }
                                        None => {
                                            *base.add(12).cast::<u8>() = (0i32) as u8;
                                        }
                                    };
                                }
                                WitNode::EnumValue(e) => {
                                    *base.add(0).cast::<u8>() = (2i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                WitNode::FlagsValue(e) => {
                                    *base.add(0).cast::<u8>() = (3i32) as u8;
                                    let vec4 = e;
                                    let len4 = vec4.len();
                                    let layout4 = _rt::alloc::Layout::from_size_align_unchecked(
                                        vec4.len() * 1,
                                        1,
                                    );
                                    let result4 = if layout4.size() != 0 {
                                        let ptr = _rt::alloc::alloc(layout4).cast::<u8>();
                                        if ptr.is_null() {
                                            _rt::alloc::handle_alloc_error(layout4);
                                        }
                                        ptr
                                    } else {
                                        ::core::ptr::null_mut()
                                    };
                                    for (i, e) in vec4.into_iter().enumerate() {
                                        let base = result4.add(i * 1);
                                        {
                                            *base.add(0).cast::<u8>() = (match e {
                                                true => 1,
                                                false => 0,
                                            }) as u8;
                                        }
                                    }
                                    *base.add(12).cast::<usize>() = len4;
                                    *base.add(8).cast::<*mut u8>() = result4;
                                    cleanup_list.extend_from_slice(&[(result4, layout4)]);
                                }
                                WitNode::TupleValue(e) => {
                                    *base.add(0).cast::<u8>() = (4i32) as u8;
                                    let vec5 = e;
                                    let ptr5 = vec5.as_ptr().cast::<u8>();
                                    let len5 = vec5.len();
                                    *base.add(12).cast::<usize>() = len5;
                                    *base.add(8).cast::<*mut u8>() = ptr5.cast_mut();
                                }
                                WitNode::ListValue(e) => {
                                    *base.add(0).cast::<u8>() = (5i32) as u8;
                                    let vec6 = e;
                                    let ptr6 = vec6.as_ptr().cast::<u8>();
                                    let len6 = vec6.len();
                                    *base.add(12).cast::<usize>() = len6;
                                    *base.add(8).cast::<*mut u8>() = ptr6.cast_mut();
                                }
                                WitNode::OptionValue(e) => {
                                    *base.add(0).cast::<u8>() = (6i32) as u8;
                                    match e {
                                        Some(e) => {
                                            *base.add(8).cast::<u8>() = (1i32) as u8;
                                            *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                        }
                                        None => {
                                            *base.add(8).cast::<u8>() = (0i32) as u8;
                                        }
                                    };
                                }
                                WitNode::ResultValue(e) => {
                                    *base.add(0).cast::<u8>() = (7i32) as u8;
                                    match e {
                                        Ok(e) => {
                                            *base.add(8).cast::<u8>() = (0i32) as u8;
                                            match e {
                                                Some(e) => {
                                                    *base.add(12).cast::<u8>() = (1i32) as u8;
                                                    *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                }
                                                None => {
                                                    *base.add(12).cast::<u8>() = (0i32) as u8;
                                                }
                                            };
                                        }
                                        Err(e) => {
                                            *base.add(8).cast::<u8>() = (1i32) as u8;
                                            match e {
                                                Some(e) => {
                                                    *base.add(12).cast::<u8>() = (1i32) as u8;
                                                    *base.add(16).cast::<i32>() = _rt::as_i32(e);
                                                }
                                                None => {
                                                    *base.add(12).cast::<u8>() = (0i32) as u8;
                                                }
                                            };
                                        }
                                    };
                                }
                                WitNode::PrimU8(e) => {
                                    *base.add(0).cast::<u8>() = (8i32) as u8;
                                    *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                }
                                WitNode::PrimU16(e) => {
                                    *base.add(0).cast::<u8>() = (9i32) as u8;
                                    *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                }
                                WitNode::PrimU32(e) => {
                                    *base.add(0).cast::<u8>() = (10i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                WitNode::PrimU64(e) => {
                                    *base.add(0).cast::<u8>() = (11i32) as u8;
                                    *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                }
                                WitNode::PrimS8(e) => {
                                    *base.add(0).cast::<u8>() = (12i32) as u8;
                                    *base.add(8).cast::<u8>() = (_rt::as_i32(e)) as u8;
                                }
                                WitNode::PrimS16(e) => {
                                    *base.add(0).cast::<u8>() = (13i32) as u8;
                                    *base.add(8).cast::<u16>() = (_rt::as_i32(e)) as u16;
                                }
                                WitNode::PrimS32(e) => {
                                    *base.add(0).cast::<u8>() = (14i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                WitNode::PrimS64(e) => {
                                    *base.add(0).cast::<u8>() = (15i32) as u8;
                                    *base.add(8).cast::<i64>() = _rt::as_i64(e);
                                }
                                WitNode::PrimFloat32(e) => {
                                    *base.add(0).cast::<u8>() = (16i32) as u8;
                                    *base.add(8).cast::<f32>() = _rt::as_f32(e);
                                }
                                WitNode::PrimFloat64(e) => {
                                    *base.add(0).cast::<u8>() = (17i32) as u8;
                                    *base.add(8).cast::<f64>() = _rt::as_f64(e);
                                }
                                WitNode::PrimChar(e) => {
                                    *base.add(0).cast::<u8>() = (18i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                WitNode::PrimBool(e) => {
                                    *base.add(0).cast::<u8>() = (19i32) as u8;
                                    *base.add(8).cast::<u8>() = (match e {
                                        true => 1,
                                        false => 0,
                                    }) as u8;
                                }
                                WitNode::PrimString(e) => {
                                    *base.add(0).cast::<u8>() = (20i32) as u8;
                                    let vec7 = e;
                                    let ptr7 = vec7.as_ptr().cast::<u8>();
                                    let len7 = vec7.len();
                                    *base.add(12).cast::<usize>() = len7;
                                    *base.add(8).cast::<*mut u8>() = ptr7.cast_mut();
                                }
                                WitNode::Handle(e) => {
                                    *base.add(0).cast::<u8>() = (21i32) as u8;
                                    let (t8_0, t8_1) = e;
                                    let Uri { value: value9 } = t8_0;
                                    let vec10 = value9;
                                    let ptr10 = vec10.as_ptr().cast::<u8>();
                                    let len10 = vec10.len();
                                    *base.add(12).cast::<usize>() = len10;
                                    *base.add(8).cast::<*mut u8>() = ptr10.cast_mut();
                                    *base.add(16).cast::<i64>() = _rt::as_i64(t8_1);
                                }
                            }
                        }
                    }
                    let WitType { nodes: nodes12 } = typ0;
                    let vec26 = nodes12;
                    let len26 = vec26.len();
                    let layout26 = _rt::alloc::Layout::from_size_align_unchecked(
                        vec26.len() * 24,
                        8,
                    );
                    let result26 = if layout26.size() != 0 {
                        let ptr = _rt::alloc::alloc(layout26).cast::<u8>();
                        if ptr.is_null() {
                            _rt::alloc::handle_alloc_error(layout26);
                        }
                        ptr
                    } else {
                        ::core::ptr::null_mut()
                    };
                    for (i, e) in vec26.into_iter().enumerate() {
                        let base = result26.add(i * 24);
                        {
                            match e {
                                WitTypeNode::RecordType(e) => {
                                    *base.add(0).cast::<u8>() = (0i32) as u8;
                                    let vec15 = e;
                                    let len15 = vec15.len();
                                    let layout15 = _rt::alloc::Layout::from_size_align_unchecked(
                                        vec15.len() * 12,
                                        4,
                                    );
                                    let result15 = if layout15.size() != 0 {
                                        let ptr = _rt::alloc::alloc(layout15).cast::<u8>();
                                        if ptr.is_null() {
                                            _rt::alloc::handle_alloc_error(layout15);
                                        }
                                        ptr
                                    } else {
                                        ::core::ptr::null_mut()
                                    };
                                    for (i, e) in vec15.into_iter().enumerate() {
                                        let base = result15.add(i * 12);
                                        {
                                            let (t13_0, t13_1) = e;
                                            let vec14 = t13_0;
                                            let ptr14 = vec14.as_ptr().cast::<u8>();
                                            let len14 = vec14.len();
                                            *base.add(4).cast::<usize>() = len14;
                                            *base.add(0).cast::<*mut u8>() = ptr14.cast_mut();
                                            *base.add(8).cast::<i32>() = _rt::as_i32(t13_1);
                                        }
                                    }
                                    *base.add(12).cast::<usize>() = len15;
                                    *base.add(8).cast::<*mut u8>() = result15;
                                    cleanup_list.extend_from_slice(&[(result15, layout15)]);
                                }
                                WitTypeNode::VariantType(e) => {
                                    *base.add(0).cast::<u8>() = (1i32) as u8;
                                    let vec18 = e;
                                    let len18 = vec18.len();
                                    let layout18 = _rt::alloc::Layout::from_size_align_unchecked(
                                        vec18.len() * 16,
                                        4,
                                    );
                                    let result18 = if layout18.size() != 0 {
                                        let ptr = _rt::alloc::alloc(layout18).cast::<u8>();
                                        if ptr.is_null() {
                                            _rt::alloc::handle_alloc_error(layout18);
                                        }
                                        ptr
                                    } else {
                                        ::core::ptr::null_mut()
                                    };
                                    for (i, e) in vec18.into_iter().enumerate() {
                                        let base = result18.add(i * 16);
                                        {
                                            let (t16_0, t16_1) = e;
                                            let vec17 = t16_0;
                                            let ptr17 = vec17.as_ptr().cast::<u8>();
                                            let len17 = vec17.len();
                                            *base.add(4).cast::<usize>() = len17;
                                            *base.add(0).cast::<*mut u8>() = ptr17.cast_mut();
                                            match t16_1 {
                                                Some(e) => {
                                                    *base.add(8).cast::<u8>() = (1i32) as u8;
                                                    *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                                }
                                                None => {
                                                    *base.add(8).cast::<u8>() = (0i32) as u8;
                                                }
                                            };
                                        }
                                    }
                                    *base.add(12).cast::<usize>() = len18;
                                    *base.add(8).cast::<*mut u8>() = result18;
                                    cleanup_list.extend_from_slice(&[(result18, layout18)]);
                                }
                                WitTypeNode::EnumType(e) => {
                                    *base.add(0).cast::<u8>() = (2i32) as u8;
                                    let vec20 = e;
                                    let len20 = vec20.len();
                                    let layout20 = _rt::alloc::Layout::from_size_align_unchecked(
                                        vec20.len() * 8,
                                        4,
                                    );
                                    let result20 = if layout20.size() != 0 {
                                        let ptr = _rt::alloc::alloc(layout20).cast::<u8>();
                                        if ptr.is_null() {
                                            _rt::alloc::handle_alloc_error(layout20);
                                        }
                                        ptr
                                    } else {
                                        ::core::ptr::null_mut()
                                    };
                                    for (i, e) in vec20.into_iter().enumerate() {
                                        let base = result20.add(i * 8);
                                        {
                                            let vec19 = e;
                                            let ptr19 = vec19.as_ptr().cast::<u8>();
                                            let len19 = vec19.len();
                                            *base.add(4).cast::<usize>() = len19;
                                            *base.add(0).cast::<*mut u8>() = ptr19.cast_mut();
                                        }
                                    }
                                    *base.add(12).cast::<usize>() = len20;
                                    *base.add(8).cast::<*mut u8>() = result20;
                                    cleanup_list.extend_from_slice(&[(result20, layout20)]);
                                }
                                WitTypeNode::FlagsType(e) => {
                                    *base.add(0).cast::<u8>() = (3i32) as u8;
                                    let vec22 = e;
                                    let len22 = vec22.len();
                                    let layout22 = _rt::alloc::Layout::from_size_align_unchecked(
                                        vec22.len() * 8,
                                        4,
                                    );
                                    let result22 = if layout22.size() != 0 {
                                        let ptr = _rt::alloc::alloc(layout22).cast::<u8>();
                                        if ptr.is_null() {
                                            _rt::alloc::handle_alloc_error(layout22);
                                        }
                                        ptr
                                    } else {
                                        ::core::ptr::null_mut()
                                    };
                                    for (i, e) in vec22.into_iter().enumerate() {
                                        let base = result22.add(i * 8);
                                        {
                                            let vec21 = e;
                                            let ptr21 = vec21.as_ptr().cast::<u8>();
                                            let len21 = vec21.len();
                                            *base.add(4).cast::<usize>() = len21;
                                            *base.add(0).cast::<*mut u8>() = ptr21.cast_mut();
                                        }
                                    }
                                    *base.add(12).cast::<usize>() = len22;
                                    *base.add(8).cast::<*mut u8>() = result22;
                                    cleanup_list.extend_from_slice(&[(result22, layout22)]);
                                }
                                WitTypeNode::TupleType(e) => {
                                    *base.add(0).cast::<u8>() = (4i32) as u8;
                                    let vec23 = e;
                                    let ptr23 = vec23.as_ptr().cast::<u8>();
                                    let len23 = vec23.len();
                                    *base.add(12).cast::<usize>() = len23;
                                    *base.add(8).cast::<*mut u8>() = ptr23.cast_mut();
                                }
                                WitTypeNode::ListType(e) => {
                                    *base.add(0).cast::<u8>() = (5i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                WitTypeNode::OptionType(e) => {
                                    *base.add(0).cast::<u8>() = (6i32) as u8;
                                    *base.add(8).cast::<i32>() = _rt::as_i32(e);
                                }
                                WitTypeNode::ResultType(e) => {
                                    *base.add(0).cast::<u8>() = (7i32) as u8;
                                    let (t24_0, t24_1) = e;
                                    match t24_0 {
                                        Some(e) => {
                                            *base.add(8).cast::<u8>() = (1i32) as u8;
                                            *base.add(12).cast::<i32>() = _rt::as_i32(e);
                                        }
                                        None => {
                                            *base.add(8).cast::<u8>() = (0i32) as u8;
                                        }
                                    };
                                    match t24_1 {
                                        Some(e) => {
                                            *base.add(16).cast::<u8>() = (1i32) as u8;
                                            *base.add(20).cast::<i32>() = _rt::as_i32(e);
                                        }
                                        None => {
                                            *base.add(16).cast::<u8>() = (0i32) as u8;
                                        }
                                    };
                                }
                                WitTypeNode::PrimU8Type => {
                                    *base.add(0).cast::<u8>() = (8i32) as u8;
                                }
                                WitTypeNode::PrimU16Type => {
                                    *base.add(0).cast::<u8>() = (9i32) as u8;
                                }
                                WitTypeNode::PrimU32Type => {
                                    *base.add(0).cast::<u8>() = (10i32) as u8;
                                }
                                WitTypeNode::PrimU64Type => {
                                    *base.add(0).cast::<u8>() = (11i32) as u8;
                                }
                                WitTypeNode::PrimS8Type => {
                                    *base.add(0).cast::<u8>() = (12i32) as u8;
                                }
                                WitTypeNode::PrimS16Type => {
                                    *base.add(0).cast::<u8>() = (13i32) as u8;
                                }
                                WitTypeNode::PrimS32Type => {
                                    *base.add(0).cast::<u8>() = (14i32) as u8;
                                }
                                WitTypeNode::PrimS64Type => {
                                    *base.add(0).cast::<u8>() = (15i32) as u8;
                                }
                                WitTypeNode::PrimF32Type => {
                                    *base.add(0).cast::<u8>() = (16i32) as u8;
                                }
                                WitTypeNode::PrimF64Type => {
                                    *base.add(0).cast::<u8>() = (17i32) as u8;
                                }
                                WitTypeNode::PrimCharType => {
                                    *base.add(0).cast::<u8>() = (18i32) as u8;
                                }
                                WitTypeNode::PrimBoolType => {
                                    *base.add(0).cast::<u8>() = (19i32) as u8;
                                }
                                WitTypeNode::PrimStringType => {
                                    *base.add(0).cast::<u8>() = (20i32) as u8;
                                }
                                WitTypeNode::HandleType(e) => {
                                    *base.add(0).cast::<u8>() = (21i32) as u8;
                                    let (t25_0, t25_1) = e;
                                    *base.add(8).cast::<i64>() = _rt::as_i64(t25_0);
                                    *base.add(16).cast::<u8>() = (t25_1.clone() as i32) as u8;
                                }
                            }
                        }
                    }
                    let ptr27 = ret_area.0.as_mut_ptr().cast::<u8>();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "golem:rpc/types@0.1.3")]
                    extern "C" {
                        #[link_name = "extract-type"]
                        fn wit_import(
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        );
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                    ) {
                        unreachable!()
                    }
                    wit_import(result11, len11, result26, len26, ptr27);
                    let l28 = *ptr27.add(0).cast::<*mut u8>();
                    let l29 = *ptr27.add(4).cast::<usize>();
                    let base70 = l28;
                    let len70 = l29;
                    let mut result70 = _rt::Vec::with_capacity(len70);
                    for i in 0..len70 {
                        let base = base70.add(i * 24);
                        let e70 = {
                            let l30 = i32::from(*base.add(0).cast::<u8>());
                            let v69 = match l30 {
                                0 => {
                                    let e69 = {
                                        let l31 = *base.add(8).cast::<*mut u8>();
                                        let l32 = *base.add(12).cast::<usize>();
                                        let base37 = l31;
                                        let len37 = l32;
                                        let mut result37 = _rt::Vec::with_capacity(len37);
                                        for i in 0..len37 {
                                            let base = base37.add(i * 12);
                                            let e37 = {
                                                let l33 = *base.add(0).cast::<*mut u8>();
                                                let l34 = *base.add(4).cast::<usize>();
                                                let len35 = l34;
                                                let bytes35 = _rt::Vec::from_raw_parts(
                                                    l33.cast(),
                                                    len35,
                                                    len35,
                                                );
                                                let l36 = *base.add(8).cast::<i32>();
                                                (_rt::string_lift(bytes35), l36)
                                            };
                                            result37.push(e37);
                                        }
                                        _rt::cabi_dealloc(base37, len37 * 12, 4);
                                        result37
                                    };
                                    WitTypeNode::RecordType(e69)
                                }
                                1 => {
                                    let e69 = {
                                        let l38 = *base.add(8).cast::<*mut u8>();
                                        let l39 = *base.add(12).cast::<usize>();
                                        let base45 = l38;
                                        let len45 = l39;
                                        let mut result45 = _rt::Vec::with_capacity(len45);
                                        for i in 0..len45 {
                                            let base = base45.add(i * 16);
                                            let e45 = {
                                                let l40 = *base.add(0).cast::<*mut u8>();
                                                let l41 = *base.add(4).cast::<usize>();
                                                let len42 = l41;
                                                let bytes42 = _rt::Vec::from_raw_parts(
                                                    l40.cast(),
                                                    len42,
                                                    len42,
                                                );
                                                let l43 = i32::from(*base.add(8).cast::<u8>());
                                                (
                                                    _rt::string_lift(bytes42),
                                                    match l43 {
                                                        0 => None,
                                                        1 => {
                                                            let e = {
                                                                let l44 = *base.add(12).cast::<i32>();
                                                                l44
                                                            };
                                                            Some(e)
                                                        }
                                                        _ => _rt::invalid_enum_discriminant(),
                                                    },
                                                )
                                            };
                                            result45.push(e45);
                                        }
                                        _rt::cabi_dealloc(base45, len45 * 16, 4);
                                        result45
                                    };
                                    WitTypeNode::VariantType(e69)
                                }
                                2 => {
                                    let e69 = {
                                        let l46 = *base.add(8).cast::<*mut u8>();
                                        let l47 = *base.add(12).cast::<usize>();
                                        let base51 = l46;
                                        let len51 = l47;
                                        let mut result51 = _rt::Vec::with_capacity(len51);
                                        for i in 0..len51 {
                                            let base = base51.add(i * 8);
                                            let e51 = {
                                                let l48 = *base.add(0).cast::<*mut u8>();
                                                let l49 = *base.add(4).cast::<usize>();
                                                let len50 = l49;
                                                let bytes50 = _rt::Vec::from_raw_parts(
                                                    l48.cast(),
                                                    len50,
                                                    len50,
                                                );
                                                _rt::string_lift(bytes50)
                                            };
                                            result51.push(e51);
                                        }
                                        _rt::cabi_dealloc(base51, len51 * 8, 4);
                                        result51
                                    };
                                    WitTypeNode::EnumType(e69)
                                }
                                3 => {
                                    let e69 = {
                                        let l52 = *base.add(8).cast::<*mut u8>();
                                        let l53 = *base.add(12).cast::<usize>();
                                        let base57 = l52;
                                        let len57 = l53;
                                        let mut result57 = _rt::Vec::with_capacity(len57);
                                        for i in 0..len57 {
                                            let base = base57.add(i * 8);
                                            let e57 = {
                                                let l54 = *base.add(0).cast::<*mut u8>();
                                                let l55 = *base.add(4).cast::<usize>();
                                                let len56 = l55;
                                                let bytes56 = _rt::Vec::from_raw_parts(
                                                    l54.cast(),
                                                    len56,
                                                    len56,
                                                );
                                                _rt::string_lift(bytes56)
                                            };
                                            result57.push(e57);
                                        }
                                        _rt::cabi_dealloc(base57, len57 * 8, 4);
                                        result57
                                    };
                                    WitTypeNode::FlagsType(e69)
                                }
                                4 => {
                                    let e69 = {
                                        let l58 = *base.add(8).cast::<*mut u8>();
                                        let l59 = *base.add(12).cast::<usize>();
                                        let len60 = l59;
                                        _rt::Vec::from_raw_parts(l58.cast(), len60, len60)
                                    };
                                    WitTypeNode::TupleType(e69)
                                }
                                5 => {
                                    let e69 = {
                                        let l61 = *base.add(8).cast::<i32>();
                                        l61
                                    };
                                    WitTypeNode::ListType(e69)
                                }
                                6 => {
                                    let e69 = {
                                        let l62 = *base.add(8).cast::<i32>();
                                        l62
                                    };
                                    WitTypeNode::OptionType(e69)
                                }
                                7 => {
                                    let e69 = {
                                        let l63 = i32::from(*base.add(8).cast::<u8>());
                                        let l65 = i32::from(*base.add(16).cast::<u8>());
                                        (
                                            match l63 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l64 = *base.add(12).cast::<i32>();
                                                        l64
                                                    };
                                                    Some(e)
                                                }
                                                _ => _rt::invalid_enum_discriminant(),
                                            },
                                            match l65 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l66 = *base.add(20).cast::<i32>();
                                                        l66
                                                    };
                                                    Some(e)
                                                }
                                                _ => _rt::invalid_enum_discriminant(),
                                            },
                                        )
                                    };
                                    WitTypeNode::ResultType(e69)
                                }
                                8 => WitTypeNode::PrimU8Type,
                                9 => WitTypeNode::PrimU16Type,
                                10 => WitTypeNode::PrimU32Type,
                                11 => WitTypeNode::PrimU64Type,
                                12 => WitTypeNode::PrimS8Type,
                                13 => WitTypeNode::PrimS16Type,
                                14 => WitTypeNode::PrimS32Type,
                                15 => WitTypeNode::PrimS64Type,
                                16 => WitTypeNode::PrimF32Type,
                                17 => WitTypeNode::PrimF64Type,
                                18 => WitTypeNode::PrimCharType,
                                19 => WitTypeNode::PrimBoolType,
                                20 => WitTypeNode::PrimStringType,
                                n => {
                                    debug_assert_eq!(n, 21, "invalid enum discriminant");
                                    let e69 = {
                                        let l67 = *base.add(8).cast::<i64>();
                                        let l68 = i32::from(*base.add(16).cast::<u8>());
                                        (l67 as u64, ResourceMode::_lift(l68 as u8))
                                    };
                                    WitTypeNode::HandleType(e69)
                                }
                            };
                            v69
                        };
                        result70.push(e70);
                    }
                    _rt::cabi_dealloc(base70, len70 * 24, 8);
                    if layout11.size() != 0 {
                        _rt::alloc::dealloc(result11.cast(), layout11);
                    }
                    if layout26.size() != 0 {
                        _rt::alloc::dealloc(result26.cast(), layout26);
                    }
                    for (ptr, layout) in cleanup_list {
                        if layout.size() != 0 {
                            _rt::alloc::dealloc(ptr.cast(), layout);
                        }
                    }
                    WitType { nodes: result70 }
                }
            }
        }
    }
}
#[rustfmt::skip]
#[allow(dead_code, clippy::all)]
pub mod wasi {
    pub mod blobstore {
        /// Types used by blobstore
        #[allow(dead_code, 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 InputStream = super::super::super::wasi::io::streams::InputStream;
            pub type OutputStream = super::super::super::wasi::io::streams::OutputStream;
            /// name of a container, a collection of objects.
            /// The container name may be any valid UTF-8 string.
            pub type ContainerName = _rt::String;
            /// name of an object within a container
            /// The object name may be any valid UTF-8 string.
            pub type ObjectName = _rt::String;
            /// TODO: define timestamp to include seconds since
            /// Unix epoch and nanoseconds
            /// https://github.com/WebAssembly/wasi-blob-store/issues/7
            pub type Timestamp = u64;
            /// size of an object, in bytes
            pub type ObjectSize = u64;
            pub type Error = _rt::String;
            /// information about a container
            #[derive(Clone)]
            pub struct ContainerMetadata {
                /// the container's name
                pub name: ContainerName,
                /// date and time container was created
                pub created_at: Timestamp,
            }
            impl ::core::fmt::Debug for ContainerMetadata {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("ContainerMetadata")
                        .field("name", &self.name)
                        .field("created-at", &self.created_at)
                        .finish()
                }
            }
            /// information about an object
            #[derive(Clone)]
            pub struct ObjectMetadata {
                /// the object's name
                pub name: ObjectName,
                /// the object's parent container
                pub container: ContainerName,
                /// date and time the object was created
                pub created_at: Timestamp,
                /// size of the object, in bytes
                pub size: ObjectSize,
            }
            impl ::core::fmt::Debug for ObjectMetadata {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("ObjectMetadata")
                        .field("name", &self.name)
                        .field("container", &self.container)
                        .field("created-at", &self.created_at)
                        .field("size", &self.size)
                        .finish()
                }
            }
            /// identifier for an object that includes its container name
            #[derive(Clone)]
            pub struct ObjectId {
                pub container: ContainerName,
                pub object: ObjectName,
            }
            impl ::core::fmt::Debug for ObjectId {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("ObjectId")
                        .field("container", &self.container)
                        .field("object", &self.object)
                        .finish()
                }
            }
            /// A data is the data stored in a data blob. The value can be of any type
            /// that can be represented in a byte array. It provides a way to write the value
            /// to the output-stream defined in the `wasi-io` interface.
            /// Soon: switch to `resource value { ... }`
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct OutgoingValue {
                handle: _rt::Resource<OutgoingValue>,
            }
            impl OutgoingValue {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 OutgoingValue {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:blobstore/types")]
                        extern "C" {
                            #[link_name = "[resource-drop]outgoing-value"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            /// A incoming-value is a wrapper around a value. It provides a way to read the value
            /// from the input-stream defined in the `wasi-io` interface.
            ///
            /// The incoming-value provides two ways to consume the value:
            /// 1. `incoming-value-consume-sync` consumes the value synchronously and returns the
            /// value as a list of bytes.
            /// 2. `incoming-value-consume-async` consumes the value asynchronously and returns the
            /// value as an input-stream.
            /// Soon: switch to `resource incoming-value { ... }`
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct IncomingValue {
                handle: _rt::Resource<IncomingValue>,
            }
            impl IncomingValue {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 IncomingValue {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:blobstore/types")]
                        extern "C" {
                            #[link_name = "[resource-drop]incoming-value"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            pub type IncomingValueAsyncBody = InputStream;
            pub type IncomingValueSyncBody = _rt::Vec<u8>;
            impl OutgoingValue {
                #[allow(unused_unsafe, clippy::all)]
                pub fn new_outgoing_value() -> OutgoingValue {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:blobstore/types")]
                        extern "C" {
                            #[link_name = "[static]outgoing-value.new-outgoing-value"]
                            fn wit_import() -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import() -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import();
                        OutgoingValue::from_handle(ret as u32)
                    }
                }
            }
            impl OutgoingValue {
                #[allow(unused_unsafe, clippy::all)]
                pub fn outgoing_value_write_body(&self) -> Result<OutputStream, ()> {
                    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:blobstore/types")]
                        extern "C" {
                            #[link_name = "[method]outgoing-value.outgoing-value-write-body"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<i32>();
                                    super::super::super::wasi::io::streams::OutputStream::from_handle(
                                        l2 as u32,
                                    )
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = ();
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl IncomingValue {
                #[allow(unused_unsafe, clippy::all)]
                pub fn incoming_value_consume_sync(
                    &self,
                ) -> Result<IncomingValueSyncBody, Error> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:blobstore/types")]
                        extern "C" {
                            #[link_name = "[method]incoming-value.incoming-value-consume-sync"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<*mut u8>();
                                    let l3 = *ptr0.add(8).cast::<usize>();
                                    let len4 = l3;
                                    _rt::Vec::from_raw_parts(l2.cast(), len4, len4)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l5 = *ptr0.add(4).cast::<*mut u8>();
                                    let l6 = *ptr0.add(8).cast::<usize>();
                                    let len7 = l6;
                                    let bytes7 = _rt::Vec::from_raw_parts(
                                        l5.cast(),
                                        len7,
                                        len7,
                                    );
                                    _rt::string_lift(bytes7)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl IncomingValue {
                #[allow(unused_unsafe, clippy::all)]
                pub fn incoming_value_consume_async(
                    &self,
                ) -> Result<IncomingValueAsyncBody, Error> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:blobstore/types")]
                        extern "C" {
                            #[link_name = "[method]incoming-value.incoming-value-consume-async"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<i32>();
                                    super::super::super::wasi::io::streams::InputStream::from_handle(
                                        l2 as u32,
                                    )
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = *ptr0.add(4).cast::<*mut u8>();
                                    let l4 = *ptr0.add(8).cast::<usize>();
                                    let len5 = l4;
                                    let bytes5 = _rt::Vec::from_raw_parts(
                                        l3.cast(),
                                        len5,
                                        len5,
                                    );
                                    _rt::string_lift(bytes5)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl IncomingValue {
                #[allow(unused_unsafe, clippy::all)]
                pub fn size(&self) -> u64 {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:blobstore/types")]
                        extern "C" {
                            #[link_name = "[method]incoming-value.size"]
                            fn wit_import(_: i32) -> i64;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32) -> i64 {
                            unreachable!()
                        }
                        let ret = wit_import((self).handle() as i32);
                        ret as u64
                    }
                }
            }
        }
        /// a Container is a collection of objects
        #[allow(dead_code, clippy::all)]
        pub mod container {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            use super::super::super::_rt;
            pub type ContainerMetadata = super::super::super::wasi::blobstore::types::ContainerMetadata;
            pub type Error = super::super::super::wasi::blobstore::types::Error;
            pub type IncomingValue = super::super::super::wasi::blobstore::types::IncomingValue;
            pub type ObjectMetadata = super::super::super::wasi::blobstore::types::ObjectMetadata;
            pub type ObjectName = super::super::super::wasi::blobstore::types::ObjectName;
            pub type OutgoingValue = super::super::super::wasi::blobstore::types::OutgoingValue;
            /// this defines the `container` resource
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct Container {
                handle: _rt::Resource<Container>,
            }
            impl Container {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 Container {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:blobstore/container")]
                        extern "C" {
                            #[link_name = "[resource-drop]container"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            /// this defines the `stream-object-names` resource which is a representation of stream<object-name>
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct StreamObjectNames {
                handle: _rt::Resource<StreamObjectNames>,
            }
            impl StreamObjectNames {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 StreamObjectNames {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:blobstore/container")]
                        extern "C" {
                            #[link_name = "[resource-drop]stream-object-names"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            impl Container {
                #[allow(unused_unsafe, clippy::all)]
                /// returns container name
                pub fn name(&self) -> Result<_rt::String, Error> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:blobstore/container")]
                        extern "C" {
                            #[link_name = "[method]container.name"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<*mut u8>();
                                    let l3 = *ptr0.add(8).cast::<usize>();
                                    let len4 = l3;
                                    let bytes4 = _rt::Vec::from_raw_parts(
                                        l2.cast(),
                                        len4,
                                        len4,
                                    );
                                    _rt::string_lift(bytes4)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l5 = *ptr0.add(4).cast::<*mut u8>();
                                    let l6 = *ptr0.add(8).cast::<usize>();
                                    let len7 = l6;
                                    let bytes7 = _rt::Vec::from_raw_parts(
                                        l5.cast(),
                                        len7,
                                        len7,
                                    );
                                    _rt::string_lift(bytes7)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Container {
                #[allow(unused_unsafe, clippy::all)]
                /// returns container metadata
                pub fn info(&self) -> Result<ContainerMetadata, Error> {
                    unsafe {
                        #[repr(align(8))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 24]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 24],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:blobstore/container")]
                        extern "C" {
                            #[link_name = "[method]container.info"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(8).cast::<*mut u8>();
                                    let l3 = *ptr0.add(12).cast::<usize>();
                                    let len4 = l3;
                                    let bytes4 = _rt::Vec::from_raw_parts(
                                        l2.cast(),
                                        len4,
                                        len4,
                                    );
                                    let l5 = *ptr0.add(16).cast::<i64>();
                                    super::super::super::wasi::blobstore::types::ContainerMetadata {
                                        name: _rt::string_lift(bytes4),
                                        created_at: l5 as u64,
                                    }
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l6 = *ptr0.add(8).cast::<*mut u8>();
                                    let l7 = *ptr0.add(12).cast::<usize>();
                                    let len8 = l7;
                                    let bytes8 = _rt::Vec::from_raw_parts(
                                        l6.cast(),
                                        len8,
                                        len8,
                                    );
                                    _rt::string_lift(bytes8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Container {
                #[allow(unused_unsafe, clippy::all)]
                /// retrieves an object or portion of an object, as a resource.
                /// Start and end offsets are inclusive.
                /// Once a data-blob resource has been created, the underlying bytes are held by the blobstore service for the lifetime
                /// of the data-blob resource, even if the object they came from is later deleted.
                pub fn get_data(
                    &self,
                    name: &ObjectName,
                    start: u64,
                    end: u64,
                ) -> Result<IncomingValue, Error> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        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:blobstore/container")]
                        extern "C" {
                            #[link_name = "[method]container.get-data"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: i64,
                                _: i64,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: i64,
                            _: i64,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            _rt::as_i64(&start),
                            _rt::as_i64(&end),
                            ptr1,
                        );
                        let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                        match l2 {
                            0 => {
                                let e = {
                                    let l3 = *ptr1.add(4).cast::<i32>();
                                    super::super::super::wasi::blobstore::types::IncomingValue::from_handle(
                                        l3 as u32,
                                    )
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l4 = *ptr1.add(4).cast::<*mut u8>();
                                    let l5 = *ptr1.add(8).cast::<usize>();
                                    let len6 = l5;
                                    let bytes6 = _rt::Vec::from_raw_parts(
                                        l4.cast(),
                                        len6,
                                        len6,
                                    );
                                    _rt::string_lift(bytes6)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Container {
                #[allow(unused_unsafe, clippy::all)]
                /// creates or replaces an object with the data blob.
                pub fn write_data(
                    &self,
                    name: &ObjectName,
                    data: &OutgoingValue,
                ) -> Result<(), Error> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        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:blobstore/container")]
                        extern "C" {
                            #[link_name = "[method]container.write-data"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: i32,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            (data).handle() as i32,
                            ptr1,
                        );
                        let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                        match l2 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = *ptr1.add(4).cast::<*mut u8>();
                                    let l4 = *ptr1.add(8).cast::<usize>();
                                    let len5 = l4;
                                    let bytes5 = _rt::Vec::from_raw_parts(
                                        l3.cast(),
                                        len5,
                                        len5,
                                    );
                                    _rt::string_lift(bytes5)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Container {
                #[allow(unused_unsafe, clippy::all)]
                /// returns list of objects in the container. Order is undefined.
                pub fn list_objects(&self) -> Result<StreamObjectNames, Error> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:blobstore/container")]
                        extern "C" {
                            #[link_name = "[method]container.list-objects"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<i32>();
                                    StreamObjectNames::from_handle(l2 as u32)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = *ptr0.add(4).cast::<*mut u8>();
                                    let l4 = *ptr0.add(8).cast::<usize>();
                                    let len5 = l4;
                                    let bytes5 = _rt::Vec::from_raw_parts(
                                        l3.cast(),
                                        len5,
                                        len5,
                                    );
                                    _rt::string_lift(bytes5)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Container {
                #[allow(unused_unsafe, clippy::all)]
                /// deletes object.
                /// does not return error if object did not exist.
                pub fn delete_object(&self, name: &ObjectName) -> Result<(), Error> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        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:blobstore/container")]
                        extern "C" {
                            #[link_name = "[method]container.delete-object"]
                            fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0.cast_mut(), len0, ptr1);
                        let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                        match l2 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = *ptr1.add(4).cast::<*mut u8>();
                                    let l4 = *ptr1.add(8).cast::<usize>();
                                    let len5 = l4;
                                    let bytes5 = _rt::Vec::from_raw_parts(
                                        l3.cast(),
                                        len5,
                                        len5,
                                    );
                                    _rt::string_lift(bytes5)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Container {
                #[allow(unused_unsafe, clippy::all)]
                /// deletes multiple objects in the container
                pub fn delete_objects(&self, names: &[ObjectName]) -> Result<(), Error> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let vec1 = names;
                        let len1 = vec1.len();
                        let layout1 = _rt::alloc::Layout::from_size_align_unchecked(
                            vec1.len() * 8,
                            4,
                        );
                        let result1 = if layout1.size() != 0 {
                            let ptr = _rt::alloc::alloc(layout1).cast::<u8>();
                            if ptr.is_null() {
                                _rt::alloc::handle_alloc_error(layout1);
                            }
                            ptr
                        } else {
                            ::core::ptr::null_mut()
                        };
                        for (i, e) in vec1.into_iter().enumerate() {
                            let base = result1.add(i * 8);
                            {
                                let vec0 = e;
                                let ptr0 = vec0.as_ptr().cast::<u8>();
                                let len0 = vec0.len();
                                *base.add(4).cast::<usize>() = len0;
                                *base.add(0).cast::<*mut u8>() = ptr0.cast_mut();
                            }
                        }
                        let ptr2 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:blobstore/container")]
                        extern "C" {
                            #[link_name = "[method]container.delete-objects"]
                            fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, result1, len1, ptr2);
                        let l3 = i32::from(*ptr2.add(0).cast::<u8>());
                        if layout1.size() != 0 {
                            _rt::alloc::dealloc(result1.cast(), layout1);
                        }
                        match l3 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l4 = *ptr2.add(4).cast::<*mut u8>();
                                    let l5 = *ptr2.add(8).cast::<usize>();
                                    let len6 = l5;
                                    let bytes6 = _rt::Vec::from_raw_parts(
                                        l4.cast(),
                                        len6,
                                        len6,
                                    );
                                    _rt::string_lift(bytes6)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Container {
                #[allow(unused_unsafe, clippy::all)]
                /// returns true if the object exists in this container
                pub fn has_object(&self, name: &ObjectName) -> Result<bool, Error> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        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:blobstore/container")]
                        extern "C" {
                            #[link_name = "[method]container.has-object"]
                            fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0.cast_mut(), len0, ptr1);
                        let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                        match l2 {
                            0 => {
                                let e = {
                                    let l3 = i32::from(*ptr1.add(4).cast::<u8>());
                                    _rt::bool_lift(l3 as u8)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l4 = *ptr1.add(4).cast::<*mut u8>();
                                    let l5 = *ptr1.add(8).cast::<usize>();
                                    let len6 = l5;
                                    let bytes6 = _rt::Vec::from_raw_parts(
                                        l4.cast(),
                                        len6,
                                        len6,
                                    );
                                    _rt::string_lift(bytes6)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Container {
                #[allow(unused_unsafe, clippy::all)]
                /// returns metadata for the object
                pub fn object_info(
                    &self,
                    name: &ObjectName,
                ) -> Result<ObjectMetadata, Error> {
                    unsafe {
                        #[repr(align(8))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 40]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 40],
                        );
                        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:blobstore/container")]
                        extern "C" {
                            #[link_name = "[method]container.object-info"]
                            fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0.cast_mut(), len0, ptr1);
                        let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                        match l2 {
                            0 => {
                                let e = {
                                    let l3 = *ptr1.add(8).cast::<*mut u8>();
                                    let l4 = *ptr1.add(12).cast::<usize>();
                                    let len5 = l4;
                                    let bytes5 = _rt::Vec::from_raw_parts(
                                        l3.cast(),
                                        len5,
                                        len5,
                                    );
                                    let l6 = *ptr1.add(16).cast::<*mut u8>();
                                    let l7 = *ptr1.add(20).cast::<usize>();
                                    let len8 = l7;
                                    let bytes8 = _rt::Vec::from_raw_parts(
                                        l6.cast(),
                                        len8,
                                        len8,
                                    );
                                    let l9 = *ptr1.add(24).cast::<i64>();
                                    let l10 = *ptr1.add(32).cast::<i64>();
                                    super::super::super::wasi::blobstore::types::ObjectMetadata {
                                        name: _rt::string_lift(bytes5),
                                        container: _rt::string_lift(bytes8),
                                        created_at: l9 as u64,
                                        size: l10 as u64,
                                    }
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l11 = *ptr1.add(8).cast::<*mut u8>();
                                    let l12 = *ptr1.add(12).cast::<usize>();
                                    let len13 = l12;
                                    let bytes13 = _rt::Vec::from_raw_parts(
                                        l11.cast(),
                                        len13,
                                        len13,
                                    );
                                    _rt::string_lift(bytes13)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Container {
                #[allow(unused_unsafe, clippy::all)]
                /// removes all objects within the container, leaving the container empty.
                pub fn clear(&self) -> Result<(), Error> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:blobstore/container")]
                        extern "C" {
                            #[link_name = "[method]container.clear"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<*mut u8>();
                                    let l3 = *ptr0.add(8).cast::<usize>();
                                    let len4 = l3;
                                    let bytes4 = _rt::Vec::from_raw_parts(
                                        l2.cast(),
                                        len4,
                                        len4,
                                    );
                                    _rt::string_lift(bytes4)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl StreamObjectNames {
                #[allow(unused_unsafe, clippy::all)]
                /// reads the next number of objects from the stream
                ///
                /// This function returns the list of objects read, and a boolean indicating if the end of the stream was reached.
                pub fn read_stream_object_names(
                    &self,
                    len: u64,
                ) -> Result<(_rt::Vec<ObjectName>, bool), Error> {
                    unsafe {
                        #[repr(align(4))]
                        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:blobstore/container")]
                        extern "C" {
                            #[link_name = "[method]stream-object-names.read-stream-object-names"]
                            fn wit_import(_: i32, _: i64, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i64, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, _rt::as_i64(&len), ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<*mut u8>();
                                    let l3 = *ptr0.add(8).cast::<usize>();
                                    let base7 = l2;
                                    let len7 = l3;
                                    let mut result7 = _rt::Vec::with_capacity(len7);
                                    for i in 0..len7 {
                                        let base = base7.add(i * 8);
                                        let e7 = {
                                            let l4 = *base.add(0).cast::<*mut u8>();
                                            let l5 = *base.add(4).cast::<usize>();
                                            let len6 = l5;
                                            let bytes6 = _rt::Vec::from_raw_parts(
                                                l4.cast(),
                                                len6,
                                                len6,
                                            );
                                            _rt::string_lift(bytes6)
                                        };
                                        result7.push(e7);
                                    }
                                    _rt::cabi_dealloc(base7, len7 * 8, 4);
                                    let l8 = i32::from(*ptr0.add(12).cast::<u8>());
                                    (result7, _rt::bool_lift(l8 as u8))
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l9 = *ptr0.add(4).cast::<*mut u8>();
                                    let l10 = *ptr0.add(8).cast::<usize>();
                                    let len11 = l10;
                                    let bytes11 = _rt::Vec::from_raw_parts(
                                        l9.cast(),
                                        len11,
                                        len11,
                                    );
                                    _rt::string_lift(bytes11)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl StreamObjectNames {
                #[allow(unused_unsafe, clippy::all)]
                /// skip the next number of objects in the stream
                ///
                /// This function returns the number of objects skipped, and a boolean indicating if the end of the stream was reached.
                pub fn skip_stream_object_names(
                    &self,
                    num: u64,
                ) -> Result<(u64, bool), Error> {
                    unsafe {
                        #[repr(align(8))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 24]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 24],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:blobstore/container")]
                        extern "C" {
                            #[link_name = "[method]stream-object-names.skip-stream-object-names"]
                            fn wit_import(_: i32, _: i64, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i64, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, _rt::as_i64(&num), ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(8).cast::<i64>();
                                    let l3 = i32::from(*ptr0.add(16).cast::<u8>());
                                    (l2 as u64, _rt::bool_lift(l3 as u8))
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l4 = *ptr0.add(8).cast::<*mut u8>();
                                    let l5 = *ptr0.add(12).cast::<usize>();
                                    let len6 = l5;
                                    let bytes6 = _rt::Vec::from_raw_parts(
                                        l4.cast(),
                                        len6,
                                        len6,
                                    );
                                    _rt::string_lift(bytes6)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
        }
        /// wasi-cloud Blobstore service definition
        #[allow(dead_code, clippy::all)]
        pub mod blobstore {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            use super::super::super::_rt;
            pub type Container = super::super::super::wasi::blobstore::container::Container;
            pub type Error = super::super::super::wasi::blobstore::types::Error;
            pub type ContainerName = super::super::super::wasi::blobstore::types::ContainerName;
            pub type ObjectId = super::super::super::wasi::blobstore::types::ObjectId;
            #[allow(unused_unsafe, clippy::all)]
            /// creates a new empty container
            pub fn create_container(name: &ContainerName) -> Result<Container, Error> {
                unsafe {
                    #[repr(align(4))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]);
                    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:blobstore/blobstore")]
                    extern "C" {
                        #[link_name = "create-container"]
                        fn wit_import(_: *mut u8, _: usize, _: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: *mut u8, _: usize, _: *mut u8) {
                        unreachable!()
                    }
                    wit_import(ptr0.cast_mut(), len0, ptr1);
                    let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                    match l2 {
                        0 => {
                            let e = {
                                let l3 = *ptr1.add(4).cast::<i32>();
                                super::super::super::wasi::blobstore::container::Container::from_handle(
                                    l3 as u32,
                                )
                            };
                            Ok(e)
                        }
                        1 => {
                            let e = {
                                let l4 = *ptr1.add(4).cast::<*mut u8>();
                                let l5 = *ptr1.add(8).cast::<usize>();
                                let len6 = l5;
                                let bytes6 = _rt::Vec::from_raw_parts(
                                    l4.cast(),
                                    len6,
                                    len6,
                                );
                                _rt::string_lift(bytes6)
                            };
                            Err(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// retrieves a container by name
            pub fn get_container(name: &ContainerName) -> Result<Container, Error> {
                unsafe {
                    #[repr(align(4))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]);
                    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:blobstore/blobstore")]
                    extern "C" {
                        #[link_name = "get-container"]
                        fn wit_import(_: *mut u8, _: usize, _: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: *mut u8, _: usize, _: *mut u8) {
                        unreachable!()
                    }
                    wit_import(ptr0.cast_mut(), len0, ptr1);
                    let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                    match l2 {
                        0 => {
                            let e = {
                                let l3 = *ptr1.add(4).cast::<i32>();
                                super::super::super::wasi::blobstore::container::Container::from_handle(
                                    l3 as u32,
                                )
                            };
                            Ok(e)
                        }
                        1 => {
                            let e = {
                                let l4 = *ptr1.add(4).cast::<*mut u8>();
                                let l5 = *ptr1.add(8).cast::<usize>();
                                let len6 = l5;
                                let bytes6 = _rt::Vec::from_raw_parts(
                                    l4.cast(),
                                    len6,
                                    len6,
                                );
                                _rt::string_lift(bytes6)
                            };
                            Err(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// deletes a container and all objects within it
            pub fn delete_container(name: &ContainerName) -> Result<(), Error> {
                unsafe {
                    #[repr(align(4))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]);
                    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:blobstore/blobstore")]
                    extern "C" {
                        #[link_name = "delete-container"]
                        fn wit_import(_: *mut u8, _: usize, _: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: *mut u8, _: usize, _: *mut u8) {
                        unreachable!()
                    }
                    wit_import(ptr0.cast_mut(), len0, ptr1);
                    let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                    match l2 {
                        0 => {
                            let e = ();
                            Ok(e)
                        }
                        1 => {
                            let e = {
                                let l3 = *ptr1.add(4).cast::<*mut u8>();
                                let l4 = *ptr1.add(8).cast::<usize>();
                                let len5 = l4;
                                let bytes5 = _rt::Vec::from_raw_parts(
                                    l3.cast(),
                                    len5,
                                    len5,
                                );
                                _rt::string_lift(bytes5)
                            };
                            Err(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// returns true if the container exists
            pub fn container_exists(name: &ContainerName) -> Result<bool, Error> {
                unsafe {
                    #[repr(align(4))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]);
                    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:blobstore/blobstore")]
                    extern "C" {
                        #[link_name = "container-exists"]
                        fn wit_import(_: *mut u8, _: usize, _: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: *mut u8, _: usize, _: *mut u8) {
                        unreachable!()
                    }
                    wit_import(ptr0.cast_mut(), len0, ptr1);
                    let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                    match l2 {
                        0 => {
                            let e = {
                                let l3 = i32::from(*ptr1.add(4).cast::<u8>());
                                _rt::bool_lift(l3 as u8)
                            };
                            Ok(e)
                        }
                        1 => {
                            let e = {
                                let l4 = *ptr1.add(4).cast::<*mut u8>();
                                let l5 = *ptr1.add(8).cast::<usize>();
                                let len6 = l5;
                                let bytes6 = _rt::Vec::from_raw_parts(
                                    l4.cast(),
                                    len6,
                                    len6,
                                );
                                _rt::string_lift(bytes6)
                            };
                            Err(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// copies (duplicates) an object, to the same or a different container.
            /// returns an error if the target container does not exist.
            /// overwrites destination object if it already existed.
            pub fn copy_object(src: &ObjectId, dest: &ObjectId) -> Result<(), Error> {
                unsafe {
                    #[repr(align(4))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]);
                    let super::super::super::wasi::blobstore::types::ObjectId {
                        container: container0,
                        object: object0,
                    } = src;
                    let vec1 = container0;
                    let ptr1 = vec1.as_ptr().cast::<u8>();
                    let len1 = vec1.len();
                    let vec2 = object0;
                    let ptr2 = vec2.as_ptr().cast::<u8>();
                    let len2 = vec2.len();
                    let super::super::super::wasi::blobstore::types::ObjectId {
                        container: container3,
                        object: object3,
                    } = dest;
                    let vec4 = container3;
                    let ptr4 = vec4.as_ptr().cast::<u8>();
                    let len4 = vec4.len();
                    let vec5 = object3;
                    let ptr5 = vec5.as_ptr().cast::<u8>();
                    let len5 = vec5.len();
                    let ptr6 = ret_area.0.as_mut_ptr().cast::<u8>();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "wasi:blobstore/blobstore")]
                    extern "C" {
                        #[link_name = "copy-object"]
                        fn wit_import(
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        );
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                    ) {
                        unreachable!()
                    }
                    wit_import(
                        ptr1.cast_mut(),
                        len1,
                        ptr2.cast_mut(),
                        len2,
                        ptr4.cast_mut(),
                        len4,
                        ptr5.cast_mut(),
                        len5,
                        ptr6,
                    );
                    let l7 = i32::from(*ptr6.add(0).cast::<u8>());
                    match l7 {
                        0 => {
                            let e = ();
                            Ok(e)
                        }
                        1 => {
                            let e = {
                                let l8 = *ptr6.add(4).cast::<*mut u8>();
                                let l9 = *ptr6.add(8).cast::<usize>();
                                let len10 = l9;
                                let bytes10 = _rt::Vec::from_raw_parts(
                                    l8.cast(),
                                    len10,
                                    len10,
                                );
                                _rt::string_lift(bytes10)
                            };
                            Err(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// moves or renames an object, to the same or a different container
            /// returns an error if the destination container does not exist.
            /// overwrites destination object if it already existed.
            pub fn move_object(src: &ObjectId, dest: &ObjectId) -> Result<(), Error> {
                unsafe {
                    #[repr(align(4))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]);
                    let super::super::super::wasi::blobstore::types::ObjectId {
                        container: container0,
                        object: object0,
                    } = src;
                    let vec1 = container0;
                    let ptr1 = vec1.as_ptr().cast::<u8>();
                    let len1 = vec1.len();
                    let vec2 = object0;
                    let ptr2 = vec2.as_ptr().cast::<u8>();
                    let len2 = vec2.len();
                    let super::super::super::wasi::blobstore::types::ObjectId {
                        container: container3,
                        object: object3,
                    } = dest;
                    let vec4 = container3;
                    let ptr4 = vec4.as_ptr().cast::<u8>();
                    let len4 = vec4.len();
                    let vec5 = object3;
                    let ptr5 = vec5.as_ptr().cast::<u8>();
                    let len5 = vec5.len();
                    let ptr6 = ret_area.0.as_mut_ptr().cast::<u8>();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "wasi:blobstore/blobstore")]
                    extern "C" {
                        #[link_name = "move-object"]
                        fn wit_import(
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        );
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                        _: usize,
                        _: *mut u8,
                    ) {
                        unreachable!()
                    }
                    wit_import(
                        ptr1.cast_mut(),
                        len1,
                        ptr2.cast_mut(),
                        len2,
                        ptr4.cast_mut(),
                        len4,
                        ptr5.cast_mut(),
                        len5,
                        ptr6,
                    );
                    let l7 = i32::from(*ptr6.add(0).cast::<u8>());
                    match l7 {
                        0 => {
                            let e = ();
                            Ok(e)
                        }
                        1 => {
                            let e = {
                                let l8 = *ptr6.add(4).cast::<*mut u8>();
                                let l9 = *ptr6.add(8).cast::<usize>();
                                let len10 = l9;
                                let bytes10 = _rt::Vec::from_raw_parts(
                                    l8.cast(),
                                    len10,
                                    len10,
                                );
                                _rt::string_lift(bytes10)
                            };
                            Err(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
        }
    }
    pub mod clocks {
        /// WASI Wall Clock is a clock API intended to let users query the current
        /// time. The name "wall" makes an analogy to a "clock on the wall", which
        /// is not necessarily monotonic as it may be reset.
        ///
        /// It is intended to be portable at least between Unix-family platforms and
        /// Windows.
        ///
        /// A wall clock is a clock which measures the date and time according to
        /// some external reference.
        ///
        /// External references may be reset, so this clock is not necessarily
        /// monotonic, making it unsuitable for measuring elapsed time.
        ///
        /// It is intended for reporting the current date and time for humans.
        #[allow(dead_code, clippy::all)]
        pub mod wall_clock {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            /// A time and date in seconds plus nanoseconds.
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct Datetime {
                pub seconds: u64,
                pub nanoseconds: u32,
            }
            impl ::core::fmt::Debug for Datetime {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Datetime")
                        .field("seconds", &self.seconds)
                        .field("nanoseconds", &self.nanoseconds)
                        .finish()
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Read the current value of the clock.
            ///
            /// This clock is not monotonic, therefore calling this function repeatedly
            /// will not necessarily produce a sequence of non-decreasing values.
            ///
            /// The returned timestamps represent the number of seconds since
            /// 1970-01-01T00:00:00Z, also known as [POSIX's Seconds Since the Epoch],
            /// also known as [Unix Time].
            ///
            /// The nanoseconds field of the output is always less than 1000000000.
            ///
            /// [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16
            /// [Unix Time]: https://en.wikipedia.org/wiki/Unix_time
            pub fn now() -> Datetime {
                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:clocks/wall-clock@0.2.0")]
                    extern "C" {
                        #[link_name = "now"]
                        fn wit_import(_: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: *mut u8) {
                        unreachable!()
                    }
                    wit_import(ptr0);
                    let l1 = *ptr0.add(0).cast::<i64>();
                    let l2 = *ptr0.add(8).cast::<i32>();
                    Datetime {
                        seconds: l1 as u64,
                        nanoseconds: l2 as u32,
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Query the resolution of the clock.
            ///
            /// The nanoseconds field of the output is always less than 1000000000.
            pub fn resolution() -> Datetime {
                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:clocks/wall-clock@0.2.0")]
                    extern "C" {
                        #[link_name = "resolution"]
                        fn wit_import(_: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: *mut u8) {
                        unreachable!()
                    }
                    wit_import(ptr0);
                    let l1 = *ptr0.add(0).cast::<i64>();
                    let l2 = *ptr0.add(8).cast::<i32>();
                    Datetime {
                        seconds: l1 as u64,
                        nanoseconds: l2 as u32,
                    }
                }
            }
        }
        /// WASI Monotonic Clock is a clock API intended to let users measure elapsed
        /// time.
        ///
        /// It is intended to be portable at least between Unix-family platforms and
        /// Windows.
        ///
        /// A monotonic clock is a clock which has an unspecified initial value, and
        /// successive reads of the clock will produce non-decreasing values.
        ///
        /// It is intended for measuring elapsed time.
        #[allow(dead_code, clippy::all)]
        pub mod monotonic_clock {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            use super::super::super::_rt;
            pub type Pollable = super::super::super::wasi::io::poll::Pollable;
            /// An instant in time, in nanoseconds. An instant is relative to an
            /// unspecified initial value, and can only be compared to instances from
            /// the same monotonic-clock.
            pub type Instant = u64;
            /// A duration of time, in nanoseconds.
            pub type Duration = u64;
            #[allow(unused_unsafe, clippy::all)]
            /// Read the current value of the clock.
            ///
            /// The clock is monotonic, therefore calling this function repeatedly will
            /// produce a sequence of non-decreasing values.
            pub fn now() -> Instant {
                unsafe {
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "wasi:clocks/monotonic-clock@0.2.0")]
                    extern "C" {
                        #[link_name = "now"]
                        fn wit_import() -> i64;
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import() -> i64 {
                        unreachable!()
                    }
                    let ret = wit_import();
                    ret as u64
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Query the resolution of the clock. Returns the duration of time
            /// corresponding to a clock tick.
            pub fn resolution() -> Duration {
                unsafe {
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "wasi:clocks/monotonic-clock@0.2.0")]
                    extern "C" {
                        #[link_name = "resolution"]
                        fn wit_import() -> i64;
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import() -> i64 {
                        unreachable!()
                    }
                    let ret = wit_import();
                    ret as u64
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Create a `pollable` which will resolve once the specified instant
            /// occured.
            pub fn subscribe_instant(when: Instant) -> Pollable {
                unsafe {
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "wasi:clocks/monotonic-clock@0.2.0")]
                    extern "C" {
                        #[link_name = "subscribe-instant"]
                        fn wit_import(_: i64) -> i32;
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i64) -> i32 {
                        unreachable!()
                    }
                    let ret = wit_import(_rt::as_i64(when));
                    super::super::super::wasi::io::poll::Pollable::from_handle(
                        ret as u32,
                    )
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Create a `pollable` which will resolve once the given duration has
            /// elapsed, starting at the time at which this function was called.
            /// occured.
            pub fn subscribe_duration(when: Duration) -> Pollable {
                unsafe {
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "wasi:clocks/monotonic-clock@0.2.0")]
                    extern "C" {
                        #[link_name = "subscribe-duration"]
                        fn wit_import(_: i64) -> i32;
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i64) -> i32 {
                        unreachable!()
                    }
                    let ret = wit_import(_rt::as_i64(when));
                    super::super::super::wasi::io::poll::Pollable::from_handle(
                        ret as u32,
                    )
                }
            }
        }
    }
    pub mod filesystem {
        /// WASI filesystem is a filesystem API primarily intended to let users run WASI
        /// programs that access their files on their existing filesystems, without
        /// significant overhead.
        ///
        /// It is intended to be roughly portable between Unix-family platforms and
        /// Windows, though it does not hide many of the major differences.
        ///
        /// Paths are passed as interface-type `string`s, meaning they must consist of
        /// a sequence of Unicode Scalar Values (USVs). Some filesystems may contain
        /// paths which are not accessible by this API.
        ///
        /// The directory separator in WASI is always the forward-slash (`/`).
        ///
        /// All paths in WASI are relative paths, and are interpreted relative to a
        /// `descriptor` referring to a base directory. If a `path` argument to any WASI
        /// function starts with `/`, or if any step of resolving a `path`, including
        /// `..` and symbolic link steps, reaches a directory outside of the base
        /// directory, or reaches a symlink to an absolute or rooted path in the
        /// underlying filesystem, the function fails with `error-code::not-permitted`.
        ///
        /// For more information about WASI path resolution and sandboxing, see
        /// [WASI filesystem path resolution].
        ///
        /// [WASI filesystem path resolution]: https://github.com/WebAssembly/wasi-filesystem/blob/main/path-resolution.md
        #[allow(dead_code, 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 InputStream = super::super::super::wasi::io::streams::InputStream;
            pub type OutputStream = super::super::super::wasi::io::streams::OutputStream;
            pub type Error = super::super::super::wasi::io::streams::Error;
            pub type Datetime = super::super::super::wasi::clocks::wall_clock::Datetime;
            /// File size or length of a region within a file.
            pub type Filesize = u64;
            /// The type of a filesystem object referenced by a descriptor.
            ///
            /// Note: This was called `filetype` in earlier versions of WASI.
            #[repr(u8)]
            #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
            pub enum DescriptorType {
                /// The type of the descriptor or file is unknown or is different from
                /// any of the other types specified.
                Unknown,
                /// The descriptor refers to a block device inode.
                BlockDevice,
                /// The descriptor refers to a character device inode.
                CharacterDevice,
                /// The descriptor refers to a directory inode.
                Directory,
                /// The descriptor refers to a named pipe.
                Fifo,
                /// The file refers to a symbolic link inode.
                SymbolicLink,
                /// The descriptor refers to a regular file inode.
                RegularFile,
                /// The descriptor refers to a socket.
                Socket,
            }
            impl ::core::fmt::Debug for DescriptorType {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        DescriptorType::Unknown => {
                            f.debug_tuple("DescriptorType::Unknown").finish()
                        }
                        DescriptorType::BlockDevice => {
                            f.debug_tuple("DescriptorType::BlockDevice").finish()
                        }
                        DescriptorType::CharacterDevice => {
                            f.debug_tuple("DescriptorType::CharacterDevice").finish()
                        }
                        DescriptorType::Directory => {
                            f.debug_tuple("DescriptorType::Directory").finish()
                        }
                        DescriptorType::Fifo => {
                            f.debug_tuple("DescriptorType::Fifo").finish()
                        }
                        DescriptorType::SymbolicLink => {
                            f.debug_tuple("DescriptorType::SymbolicLink").finish()
                        }
                        DescriptorType::RegularFile => {
                            f.debug_tuple("DescriptorType::RegularFile").finish()
                        }
                        DescriptorType::Socket => {
                            f.debug_tuple("DescriptorType::Socket").finish()
                        }
                    }
                }
            }
            impl DescriptorType {
                #[doc(hidden)]
                pub unsafe fn _lift(val: u8) -> DescriptorType {
                    if !cfg!(debug_assertions) {
                        return ::core::mem::transmute(val);
                    }
                    match val {
                        0 => DescriptorType::Unknown,
                        1 => DescriptorType::BlockDevice,
                        2 => DescriptorType::CharacterDevice,
                        3 => DescriptorType::Directory,
                        4 => DescriptorType::Fifo,
                        5 => DescriptorType::SymbolicLink,
                        6 => DescriptorType::RegularFile,
                        7 => DescriptorType::Socket,
                        _ => panic!("invalid enum discriminant"),
                    }
                }
            }
            wit_bindgen_rt::bitflags::bitflags! {
                #[doc = " Descriptor flags."] #[doc = ""] #[doc =
                " Note: This was called `fdflags` in earlier versions of WASI."]
                #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)] pub
                struct DescriptorFlags : u8 { #[doc = " Read mode: Data can be read."]
                const READ = 1 << 0; #[doc = " Write mode: Data can be written to."]
                const WRITE = 1 << 1; #[doc =
                " Request that writes be performed according to synchronized I/O file"]
                #[doc =
                " integrity completion. The data stored in the file and the file's"]
                #[doc =
                " metadata are synchronized. This is similar to `O_SYNC` in POSIX."]
                #[doc = ""] #[doc =
                " The precise semantics of this operation have not yet been defined for"]
                #[doc =
                " WASI. At this time, it should be interpreted as a request, and not a"]
                #[doc = " requirement."] const FILE_INTEGRITY_SYNC = 1 << 2; #[doc =
                " Request that writes be performed according to synchronized I/O data"]
                #[doc = " integrity completion. Only the data stored in the file is"]
                #[doc = " synchronized. This is similar to `O_DSYNC` in POSIX."] #[doc =
                ""] #[doc =
                " The precise semantics of this operation have not yet been defined for"]
                #[doc =
                " WASI. At this time, it should be interpreted as a request, and not a"]
                #[doc = " requirement."] const DATA_INTEGRITY_SYNC = 1 << 3; #[doc =
                " Requests that reads be performed at the same level of integrety"] #[doc
                = " requested for writes. This is similar to `O_RSYNC` in POSIX."] #[doc
                = ""] #[doc =
                " The precise semantics of this operation have not yet been defined for"]
                #[doc =
                " WASI. At this time, it should be interpreted as a request, and not a"]
                #[doc = " requirement."] const REQUESTED_WRITE_SYNC = 1 << 4; #[doc =
                " Mutating directories mode: Directory contents may be mutated."] #[doc =
                ""] #[doc =
                " When this flag is unset on a descriptor, operations using the"] #[doc =
                " descriptor which would create, rename, delete, modify the data or"]
                #[doc =
                " metadata of filesystem objects, or obtain another handle which"] #[doc
                =
                " would permit any of those, shall fail with `error-code::read-only` if"]
                #[doc = " they would otherwise succeed."] #[doc = ""] #[doc =
                " This may only be set on directories."] const MUTATE_DIRECTORY = 1 << 5;
                }
            }
            wit_bindgen_rt::bitflags::bitflags! {
                #[doc = " Flags determining the method of how paths are resolved."]
                #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Clone, Copy)] pub
                struct PathFlags : u8 { #[doc =
                " As long as the resolved path corresponds to a symbolic link, it is"]
                #[doc = " expanded."] const SYMLINK_FOLLOW = 1 << 0; }
            }
            wit_bindgen_rt::bitflags::bitflags! {
                #[doc = " Open flags used by `open-at`."] #[derive(PartialEq, Eq,
                PartialOrd, Ord, Hash, Debug, Clone, Copy)] pub struct OpenFlags : u8 {
                #[doc =
                " Create file if it does not exist, similar to `O_CREAT` in POSIX."]
                const CREATE = 1 << 0; #[doc =
                " Fail if not a directory, similar to `O_DIRECTORY` in POSIX."] const
                DIRECTORY = 1 << 1; #[doc =
                " Fail if file already exists, similar to `O_EXCL` in POSIX."] const
                EXCLUSIVE = 1 << 2; #[doc =
                " Truncate file to size 0, similar to `O_TRUNC` in POSIX."] const
                TRUNCATE = 1 << 3; }
            }
            /// Number of hard links to an inode.
            pub type LinkCount = u64;
            /// File attributes.
            ///
            /// Note: This was called `filestat` in earlier versions of WASI.
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct DescriptorStat {
                /// File type.
                pub type_: DescriptorType,
                /// Number of hard links to the file.
                pub link_count: LinkCount,
                /// For regular files, the file size in bytes. For symbolic links, the
                /// length in bytes of the pathname contained in the symbolic link.
                pub size: Filesize,
                /// Last data access timestamp.
                ///
                /// If the `option` is none, the platform doesn't maintain an access
                /// timestamp for this file.
                pub data_access_timestamp: Option<Datetime>,
                /// Last data modification timestamp.
                ///
                /// If the `option` is none, the platform doesn't maintain a
                /// modification timestamp for this file.
                pub data_modification_timestamp: Option<Datetime>,
                /// Last file status-change timestamp.
                ///
                /// If the `option` is none, the platform doesn't maintain a
                /// status-change timestamp for this file.
                pub status_change_timestamp: Option<Datetime>,
            }
            impl ::core::fmt::Debug for DescriptorStat {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("DescriptorStat")
                        .field("type", &self.type_)
                        .field("link-count", &self.link_count)
                        .field("size", &self.size)
                        .field("data-access-timestamp", &self.data_access_timestamp)
                        .field(
                            "data-modification-timestamp",
                            &self.data_modification_timestamp,
                        )
                        .field("status-change-timestamp", &self.status_change_timestamp)
                        .finish()
                }
            }
            /// When setting a timestamp, this gives the value to set it to.
            #[derive(Clone, Copy)]
            pub enum NewTimestamp {
                /// Leave the timestamp set to its previous value.
                NoChange,
                /// Set the timestamp to the current time of the system clock associated
                /// with the filesystem.
                Now,
                /// Set the timestamp to the given value.
                Timestamp(Datetime),
            }
            impl ::core::fmt::Debug for NewTimestamp {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        NewTimestamp::NoChange => {
                            f.debug_tuple("NewTimestamp::NoChange").finish()
                        }
                        NewTimestamp::Now => f.debug_tuple("NewTimestamp::Now").finish(),
                        NewTimestamp::Timestamp(e) => {
                            f.debug_tuple("NewTimestamp::Timestamp").field(e).finish()
                        }
                    }
                }
            }
            /// A directory entry.
            #[derive(Clone)]
            pub struct DirectoryEntry {
                /// The type of the file referred to by this directory entry.
                pub type_: DescriptorType,
                /// The name of the object.
                pub name: _rt::String,
            }
            impl ::core::fmt::Debug for DirectoryEntry {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("DirectoryEntry")
                        .field("type", &self.type_)
                        .field("name", &self.name)
                        .finish()
                }
            }
            /// Error codes returned by functions, similar to `errno` in POSIX.
            /// Not all of these error codes are returned by the functions provided by this
            /// API; some are used in higher-level library layers, and others are provided
            /// merely for alignment with POSIX.
            #[repr(u8)]
            #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
            pub enum ErrorCode {
                /// Permission denied, similar to `EACCES` in POSIX.
                Access,
                /// Resource unavailable, or operation would block, similar to `EAGAIN` and `EWOULDBLOCK` in POSIX.
                WouldBlock,
                /// Connection already in progress, similar to `EALREADY` in POSIX.
                Already,
                /// Bad descriptor, similar to `EBADF` in POSIX.
                BadDescriptor,
                /// Device or resource busy, similar to `EBUSY` in POSIX.
                Busy,
                /// Resource deadlock would occur, similar to `EDEADLK` in POSIX.
                Deadlock,
                /// Storage quota exceeded, similar to `EDQUOT` in POSIX.
                Quota,
                /// File exists, similar to `EEXIST` in POSIX.
                Exist,
                /// File too large, similar to `EFBIG` in POSIX.
                FileTooLarge,
                /// Illegal byte sequence, similar to `EILSEQ` in POSIX.
                IllegalByteSequence,
                /// Operation in progress, similar to `EINPROGRESS` in POSIX.
                InProgress,
                /// Interrupted function, similar to `EINTR` in POSIX.
                Interrupted,
                /// Invalid argument, similar to `EINVAL` in POSIX.
                Invalid,
                /// I/O error, similar to `EIO` in POSIX.
                Io,
                /// Is a directory, similar to `EISDIR` in POSIX.
                IsDirectory,
                /// Too many levels of symbolic links, similar to `ELOOP` in POSIX.
                Loop,
                /// Too many links, similar to `EMLINK` in POSIX.
                TooManyLinks,
                /// Message too large, similar to `EMSGSIZE` in POSIX.
                MessageSize,
                /// Filename too long, similar to `ENAMETOOLONG` in POSIX.
                NameTooLong,
                /// No such device, similar to `ENODEV` in POSIX.
                NoDevice,
                /// No such file or directory, similar to `ENOENT` in POSIX.
                NoEntry,
                /// No locks available, similar to `ENOLCK` in POSIX.
                NoLock,
                /// Not enough space, similar to `ENOMEM` in POSIX.
                InsufficientMemory,
                /// No space left on device, similar to `ENOSPC` in POSIX.
                InsufficientSpace,
                /// Not a directory or a symbolic link to a directory, similar to `ENOTDIR` in POSIX.
                NotDirectory,
                /// Directory not empty, similar to `ENOTEMPTY` in POSIX.
                NotEmpty,
                /// State not recoverable, similar to `ENOTRECOVERABLE` in POSIX.
                NotRecoverable,
                /// Not supported, similar to `ENOTSUP` and `ENOSYS` in POSIX.
                Unsupported,
                /// Inappropriate I/O control operation, similar to `ENOTTY` in POSIX.
                NoTty,
                /// No such device or address, similar to `ENXIO` in POSIX.
                NoSuchDevice,
                /// Value too large to be stored in data type, similar to `EOVERFLOW` in POSIX.
                Overflow,
                /// Operation not permitted, similar to `EPERM` in POSIX.
                NotPermitted,
                /// Broken pipe, similar to `EPIPE` in POSIX.
                Pipe,
                /// Read-only file system, similar to `EROFS` in POSIX.
                ReadOnly,
                /// Invalid seek, similar to `ESPIPE` in POSIX.
                InvalidSeek,
                /// Text file busy, similar to `ETXTBSY` in POSIX.
                TextFileBusy,
                /// Cross-device link, similar to `EXDEV` in POSIX.
                CrossDevice,
            }
            impl ErrorCode {
                pub fn name(&self) -> &'static str {
                    match self {
                        ErrorCode::Access => "access",
                        ErrorCode::WouldBlock => "would-block",
                        ErrorCode::Already => "already",
                        ErrorCode::BadDescriptor => "bad-descriptor",
                        ErrorCode::Busy => "busy",
                        ErrorCode::Deadlock => "deadlock",
                        ErrorCode::Quota => "quota",
                        ErrorCode::Exist => "exist",
                        ErrorCode::FileTooLarge => "file-too-large",
                        ErrorCode::IllegalByteSequence => "illegal-byte-sequence",
                        ErrorCode::InProgress => "in-progress",
                        ErrorCode::Interrupted => "interrupted",
                        ErrorCode::Invalid => "invalid",
                        ErrorCode::Io => "io",
                        ErrorCode::IsDirectory => "is-directory",
                        ErrorCode::Loop => "loop",
                        ErrorCode::TooManyLinks => "too-many-links",
                        ErrorCode::MessageSize => "message-size",
                        ErrorCode::NameTooLong => "name-too-long",
                        ErrorCode::NoDevice => "no-device",
                        ErrorCode::NoEntry => "no-entry",
                        ErrorCode::NoLock => "no-lock",
                        ErrorCode::InsufficientMemory => "insufficient-memory",
                        ErrorCode::InsufficientSpace => "insufficient-space",
                        ErrorCode::NotDirectory => "not-directory",
                        ErrorCode::NotEmpty => "not-empty",
                        ErrorCode::NotRecoverable => "not-recoverable",
                        ErrorCode::Unsupported => "unsupported",
                        ErrorCode::NoTty => "no-tty",
                        ErrorCode::NoSuchDevice => "no-such-device",
                        ErrorCode::Overflow => "overflow",
                        ErrorCode::NotPermitted => "not-permitted",
                        ErrorCode::Pipe => "pipe",
                        ErrorCode::ReadOnly => "read-only",
                        ErrorCode::InvalidSeek => "invalid-seek",
                        ErrorCode::TextFileBusy => "text-file-busy",
                        ErrorCode::CrossDevice => "cross-device",
                    }
                }
                pub fn message(&self) -> &'static str {
                    match self {
                        ErrorCode::Access => {
                            "Permission denied, similar to `EACCES` in POSIX."
                        }
                        ErrorCode::WouldBlock => {
                            "Resource unavailable, or operation would block, similar to `EAGAIN` and `EWOULDBLOCK` in POSIX."
                        }
                        ErrorCode::Already => {
                            "Connection already in progress, similar to `EALREADY` in POSIX."
                        }
                        ErrorCode::BadDescriptor => {
                            "Bad descriptor, similar to `EBADF` in POSIX."
                        }
                        ErrorCode::Busy => {
                            "Device or resource busy, similar to `EBUSY` in POSIX."
                        }
                        ErrorCode::Deadlock => {
                            "Resource deadlock would occur, similar to `EDEADLK` in POSIX."
                        }
                        ErrorCode::Quota => {
                            "Storage quota exceeded, similar to `EDQUOT` in POSIX."
                        }
                        ErrorCode::Exist => "File exists, similar to `EEXIST` in POSIX.",
                        ErrorCode::FileTooLarge => {
                            "File too large, similar to `EFBIG` in POSIX."
                        }
                        ErrorCode::IllegalByteSequence => {
                            "Illegal byte sequence, similar to `EILSEQ` in POSIX."
                        }
                        ErrorCode::InProgress => {
                            "Operation in progress, similar to `EINPROGRESS` in POSIX."
                        }
                        ErrorCode::Interrupted => {
                            "Interrupted function, similar to `EINTR` in POSIX."
                        }
                        ErrorCode::Invalid => {
                            "Invalid argument, similar to `EINVAL` in POSIX."
                        }
                        ErrorCode::Io => "I/O error, similar to `EIO` in POSIX.",
                        ErrorCode::IsDirectory => {
                            "Is a directory, similar to `EISDIR` in POSIX."
                        }
                        ErrorCode::Loop => {
                            "Too many levels of symbolic links, similar to `ELOOP` in POSIX."
                        }
                        ErrorCode::TooManyLinks => {
                            "Too many links, similar to `EMLINK` in POSIX."
                        }
                        ErrorCode::MessageSize => {
                            "Message too large, similar to `EMSGSIZE` in POSIX."
                        }
                        ErrorCode::NameTooLong => {
                            "Filename too long, similar to `ENAMETOOLONG` in POSIX."
                        }
                        ErrorCode::NoDevice => {
                            "No such device, similar to `ENODEV` in POSIX."
                        }
                        ErrorCode::NoEntry => {
                            "No such file or directory, similar to `ENOENT` in POSIX."
                        }
                        ErrorCode::NoLock => {
                            "No locks available, similar to `ENOLCK` in POSIX."
                        }
                        ErrorCode::InsufficientMemory => {
                            "Not enough space, similar to `ENOMEM` in POSIX."
                        }
                        ErrorCode::InsufficientSpace => {
                            "No space left on device, similar to `ENOSPC` in POSIX."
                        }
                        ErrorCode::NotDirectory => {
                            "Not a directory or a symbolic link to a directory, similar to `ENOTDIR` in POSIX."
                        }
                        ErrorCode::NotEmpty => {
                            "Directory not empty, similar to `ENOTEMPTY` in POSIX."
                        }
                        ErrorCode::NotRecoverable => {
                            "State not recoverable, similar to `ENOTRECOVERABLE` in POSIX."
                        }
                        ErrorCode::Unsupported => {
                            "Not supported, similar to `ENOTSUP` and `ENOSYS` in POSIX."
                        }
                        ErrorCode::NoTty => {
                            "Inappropriate I/O control operation, similar to `ENOTTY` in POSIX."
                        }
                        ErrorCode::NoSuchDevice => {
                            "No such device or address, similar to `ENXIO` in POSIX."
                        }
                        ErrorCode::Overflow => {
                            "Value too large to be stored in data type, similar to `EOVERFLOW` in POSIX."
                        }
                        ErrorCode::NotPermitted => {
                            "Operation not permitted, similar to `EPERM` in POSIX."
                        }
                        ErrorCode::Pipe => "Broken pipe, similar to `EPIPE` in POSIX.",
                        ErrorCode::ReadOnly => {
                            "Read-only file system, similar to `EROFS` in POSIX."
                        }
                        ErrorCode::InvalidSeek => {
                            "Invalid seek, similar to `ESPIPE` in POSIX."
                        }
                        ErrorCode::TextFileBusy => {
                            "Text file busy, similar to `ETXTBSY` in POSIX."
                        }
                        ErrorCode::CrossDevice => {
                            "Cross-device link, similar to `EXDEV` in POSIX."
                        }
                    }
                }
            }
            impl ::core::fmt::Debug for ErrorCode {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("ErrorCode")
                        .field("code", &(*self as i32))
                        .field("name", &self.name())
                        .field("message", &self.message())
                        .finish()
                }
            }
            impl ::core::fmt::Display for ErrorCode {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    write!(f, "{} (error {})", self.name(), * self as i32)
                }
            }
            impl std::error::Error for ErrorCode {}
            impl ErrorCode {
                #[doc(hidden)]
                pub unsafe fn _lift(val: u8) -> ErrorCode {
                    if !cfg!(debug_assertions) {
                        return ::core::mem::transmute(val);
                    }
                    match val {
                        0 => ErrorCode::Access,
                        1 => ErrorCode::WouldBlock,
                        2 => ErrorCode::Already,
                        3 => ErrorCode::BadDescriptor,
                        4 => ErrorCode::Busy,
                        5 => ErrorCode::Deadlock,
                        6 => ErrorCode::Quota,
                        7 => ErrorCode::Exist,
                        8 => ErrorCode::FileTooLarge,
                        9 => ErrorCode::IllegalByteSequence,
                        10 => ErrorCode::InProgress,
                        11 => ErrorCode::Interrupted,
                        12 => ErrorCode::Invalid,
                        13 => ErrorCode::Io,
                        14 => ErrorCode::IsDirectory,
                        15 => ErrorCode::Loop,
                        16 => ErrorCode::TooManyLinks,
                        17 => ErrorCode::MessageSize,
                        18 => ErrorCode::NameTooLong,
                        19 => ErrorCode::NoDevice,
                        20 => ErrorCode::NoEntry,
                        21 => ErrorCode::NoLock,
                        22 => ErrorCode::InsufficientMemory,
                        23 => ErrorCode::InsufficientSpace,
                        24 => ErrorCode::NotDirectory,
                        25 => ErrorCode::NotEmpty,
                        26 => ErrorCode::NotRecoverable,
                        27 => ErrorCode::Unsupported,
                        28 => ErrorCode::NoTty,
                        29 => ErrorCode::NoSuchDevice,
                        30 => ErrorCode::Overflow,
                        31 => ErrorCode::NotPermitted,
                        32 => ErrorCode::Pipe,
                        33 => ErrorCode::ReadOnly,
                        34 => ErrorCode::InvalidSeek,
                        35 => ErrorCode::TextFileBusy,
                        36 => ErrorCode::CrossDevice,
                        _ => panic!("invalid enum discriminant"),
                    }
                }
            }
            /// File or memory access pattern advisory information.
            #[repr(u8)]
            #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
            pub enum Advice {
                /// The application has no advice to give on its behavior with respect
                /// to the specified data.
                Normal,
                /// The application expects to access the specified data sequentially
                /// from lower offsets to higher offsets.
                Sequential,
                /// The application expects to access the specified data in a random
                /// order.
                Random,
                /// The application expects to access the specified data in the near
                /// future.
                WillNeed,
                /// The application expects that it will not access the specified data
                /// in the near future.
                DontNeed,
                /// The application expects to access the specified data once and then
                /// not reuse it thereafter.
                NoReuse,
            }
            impl ::core::fmt::Debug for Advice {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        Advice::Normal => f.debug_tuple("Advice::Normal").finish(),
                        Advice::Sequential => {
                            f.debug_tuple("Advice::Sequential").finish()
                        }
                        Advice::Random => f.debug_tuple("Advice::Random").finish(),
                        Advice::WillNeed => f.debug_tuple("Advice::WillNeed").finish(),
                        Advice::DontNeed => f.debug_tuple("Advice::DontNeed").finish(),
                        Advice::NoReuse => f.debug_tuple("Advice::NoReuse").finish(),
                    }
                }
            }
            impl Advice {
                #[doc(hidden)]
                pub unsafe fn _lift(val: u8) -> Advice {
                    if !cfg!(debug_assertions) {
                        return ::core::mem::transmute(val);
                    }
                    match val {
                        0 => Advice::Normal,
                        1 => Advice::Sequential,
                        2 => Advice::Random,
                        3 => Advice::WillNeed,
                        4 => Advice::DontNeed,
                        5 => Advice::NoReuse,
                        _ => panic!("invalid enum discriminant"),
                    }
                }
            }
            /// A 128-bit hash value, split into parts because wasm doesn't have a
            /// 128-bit integer type.
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct MetadataHashValue {
                /// 64 bits of a 128-bit hash value.
                pub lower: u64,
                /// Another 64 bits of a 128-bit hash value.
                pub upper: u64,
            }
            impl ::core::fmt::Debug for MetadataHashValue {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("MetadataHashValue")
                        .field("lower", &self.lower)
                        .field("upper", &self.upper)
                        .finish()
                }
            }
            /// A descriptor is a reference to a filesystem object, which may be a file,
            /// directory, named pipe, special file, or other object on which filesystem
            /// calls may be made.
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct Descriptor {
                handle: _rt::Resource<Descriptor>,
            }
            impl Descriptor {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 Descriptor {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]descriptor"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            /// A stream of directory entries.
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct DirectoryEntryStream {
                handle: _rt::Resource<DirectoryEntryStream>,
            }
            impl DirectoryEntryStream {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 DirectoryEntryStream {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]directory-entry-stream"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Return a stream for reading from a file, if available.
                ///
                /// May fail with an error-code describing why the file cannot be read.
                ///
                /// Multiple read, write, and append streams may be active on the same open
                /// file and they do not interfere with each other.
                ///
                /// Note: This allows using `read-stream`, which is similar to `read` in POSIX.
                pub fn read_via_stream(
                    &self,
                    offset: Filesize,
                ) -> Result<InputStream, 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:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.read-via-stream"]
                            fn wit_import(_: i32, _: i64, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i64, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, _rt::as_i64(offset), ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<i32>();
                                    super::super::super::wasi::io::streams::InputStream::from_handle(
                                        l2 as u32,
                                    )
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = i32::from(*ptr0.add(4).cast::<u8>());
                                    ErrorCode::_lift(l3 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Return a stream for writing to a file, if available.
                ///
                /// May fail with an error-code describing why the file cannot be written.
                ///
                /// Note: This allows using `write-stream`, which is similar to `write` in
                /// POSIX.
                pub fn write_via_stream(
                    &self,
                    offset: Filesize,
                ) -> Result<OutputStream, 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:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.write-via-stream"]
                            fn wit_import(_: i32, _: i64, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i64, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, _rt::as_i64(offset), ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<i32>();
                                    super::super::super::wasi::io::streams::OutputStream::from_handle(
                                        l2 as u32,
                                    )
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = i32::from(*ptr0.add(4).cast::<u8>());
                                    ErrorCode::_lift(l3 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Return a stream for appending to a file, if available.
                ///
                /// May fail with an error-code describing why the file cannot be appended.
                ///
                /// Note: This allows using `write-stream`, which is similar to `write` with
                /// `O_APPEND` in in POSIX.
                pub fn append_via_stream(&self) -> Result<OutputStream, 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:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.append-via-stream"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<i32>();
                                    super::super::super::wasi::io::streams::OutputStream::from_handle(
                                        l2 as u32,
                                    )
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = i32::from(*ptr0.add(4).cast::<u8>());
                                    ErrorCode::_lift(l3 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Provide file advisory information on a descriptor.
                ///
                /// This is similar to `posix_fadvise` in POSIX.
                pub fn advise(
                    &self,
                    offset: Filesize,
                    length: Filesize,
                    advice: Advice,
                ) -> Result<(), ErrorCode> {
                    unsafe {
                        #[repr(align(1))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.advise"]
                            fn wit_import(_: i32, _: i64, _: i64, _: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i64, _: i64, _: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            _rt::as_i64(offset),
                            _rt::as_i64(length),
                            advice.clone() as i32,
                            ptr0,
                        );
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(1).cast::<u8>());
                                    ErrorCode::_lift(l2 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Synchronize the data of a file to disk.
                ///
                /// This function succeeds with no effect if the file descriptor is not
                /// opened for writing.
                ///
                /// Note: This is similar to `fdatasync` in POSIX.
                pub fn sync_data(&self) -> Result<(), ErrorCode> {
                    unsafe {
                        #[repr(align(1))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.sync-data"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(1).cast::<u8>());
                                    ErrorCode::_lift(l2 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Get flags associated with a descriptor.
                ///
                /// Note: This returns similar flags to `fcntl(fd, F_GETFL)` in POSIX.
                ///
                /// Note: This returns the value that was the `fs_flags` value returned
                /// from `fdstat_get` in earlier versions of WASI.
                pub fn get_flags(&self) -> Result<DescriptorFlags, ErrorCode> {
                    unsafe {
                        #[repr(align(1))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.get-flags"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(1).cast::<u8>());
                                    DescriptorFlags::empty()
                                        | DescriptorFlags::from_bits_retain(((l2 as u8) << 0) as _)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = i32::from(*ptr0.add(1).cast::<u8>());
                                    ErrorCode::_lift(l3 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Get the dynamic type of a descriptor.
                ///
                /// Note: This returns the same value as the `type` field of the `fd-stat`
                /// returned by `stat`, `stat-at` and similar.
                ///
                /// Note: This returns similar flags to the `st_mode & S_IFMT` value provided
                /// by `fstat` in POSIX.
                ///
                /// Note: This returns the value that was the `fs_filetype` value returned
                /// from `fdstat_get` in earlier versions of WASI.
                pub fn get_type(&self) -> Result<DescriptorType, ErrorCode> {
                    unsafe {
                        #[repr(align(1))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.get-type"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(1).cast::<u8>());
                                    DescriptorType::_lift(l2 as u8)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = i32::from(*ptr0.add(1).cast::<u8>());
                                    ErrorCode::_lift(l3 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Adjust the size of an open file. If this increases the file's size, the
                /// extra bytes are filled with zeros.
                ///
                /// Note: This was called `fd_filestat_set_size` in earlier versions of WASI.
                pub fn set_size(&self, size: Filesize) -> Result<(), ErrorCode> {
                    unsafe {
                        #[repr(align(1))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.set-size"]
                            fn wit_import(_: i32, _: i64, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i64, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, _rt::as_i64(size), ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(1).cast::<u8>());
                                    ErrorCode::_lift(l2 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Adjust the timestamps of an open file or directory.
                ///
                /// Note: This is similar to `futimens` in POSIX.
                ///
                /// Note: This was called `fd_filestat_set_times` in earlier versions of WASI.
                pub fn set_times(
                    &self,
                    data_access_timestamp: NewTimestamp,
                    data_modification_timestamp: NewTimestamp,
                ) -> Result<(), ErrorCode> {
                    unsafe {
                        #[repr(align(1))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2],
                        );
                        let (result1_0, result1_1, result1_2) = match data_access_timestamp {
                            NewTimestamp::NoChange => (0i32, 0i64, 0i32),
                            NewTimestamp::Now => (1i32, 0i64, 0i32),
                            NewTimestamp::Timestamp(e) => {
                                let super::super::super::wasi::clocks::wall_clock::Datetime {
                                    seconds: seconds0,
                                    nanoseconds: nanoseconds0,
                                } = e;
                                (2i32, _rt::as_i64(seconds0), _rt::as_i32(nanoseconds0))
                            }
                        };
                        let (result3_0, result3_1, result3_2) = match data_modification_timestamp {
                            NewTimestamp::NoChange => (0i32, 0i64, 0i32),
                            NewTimestamp::Now => (1i32, 0i64, 0i32),
                            NewTimestamp::Timestamp(e) => {
                                let super::super::super::wasi::clocks::wall_clock::Datetime {
                                    seconds: seconds2,
                                    nanoseconds: nanoseconds2,
                                } = e;
                                (2i32, _rt::as_i64(seconds2), _rt::as_i32(nanoseconds2))
                            }
                        };
                        let ptr4 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.set-times"]
                            fn wit_import(
                                _: i32,
                                _: i32,
                                _: i64,
                                _: i32,
                                _: i32,
                                _: i64,
                                _: i32,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: i32,
                            _: i64,
                            _: i32,
                            _: i32,
                            _: i64,
                            _: i32,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            result1_0,
                            result1_1,
                            result1_2,
                            result3_0,
                            result3_1,
                            result3_2,
                            ptr4,
                        );
                        let l5 = i32::from(*ptr4.add(0).cast::<u8>());
                        match l5 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l6 = i32::from(*ptr4.add(1).cast::<u8>());
                                    ErrorCode::_lift(l6 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Read from a descriptor, without using and updating the descriptor's offset.
                ///
                /// This function returns a list of bytes containing the data that was
                /// read, along with a bool which, when true, indicates that the end of the
                /// file was reached. The returned list will contain up to `length` bytes; it
                /// may return fewer than requested, if the end of the file is reached or
                /// if the I/O operation is interrupted.
                ///
                /// In the future, this may change to return a `stream<u8, error-code>`.
                ///
                /// Note: This is similar to `pread` in POSIX.
                pub fn read(
                    &self,
                    length: Filesize,
                    offset: Filesize,
                ) -> Result<(_rt::Vec<u8>, bool), ErrorCode> {
                    unsafe {
                        #[repr(align(4))]
                        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:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.read"]
                            fn wit_import(_: i32, _: i64, _: i64, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i64, _: i64, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            _rt::as_i64(length),
                            _rt::as_i64(offset),
                            ptr0,
                        );
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<*mut u8>();
                                    let l3 = *ptr0.add(8).cast::<usize>();
                                    let len4 = l3;
                                    let l5 = i32::from(*ptr0.add(12).cast::<u8>());
                                    (
                                        _rt::Vec::from_raw_parts(l2.cast(), len4, len4),
                                        _rt::bool_lift(l5 as u8),
                                    )
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l6 = i32::from(*ptr0.add(4).cast::<u8>());
                                    ErrorCode::_lift(l6 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Write to a descriptor, without using and updating the descriptor's offset.
                ///
                /// It is valid to write past the end of a file; the file is extended to the
                /// extent of the write, with bytes between the previous end and the start of
                /// the write set to zero.
                ///
                /// In the future, this may change to take a `stream<u8, error-code>`.
                ///
                /// Note: This is similar to `pwrite` in POSIX.
                pub fn write(
                    &self,
                    buffer: &[u8],
                    offset: Filesize,
                ) -> Result<Filesize, ErrorCode> {
                    unsafe {
                        #[repr(align(8))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 16]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 16],
                        );
                        let vec0 = buffer;
                        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:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.write"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: i64,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: i64, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            _rt::as_i64(offset),
                            ptr1,
                        );
                        let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                        match l2 {
                            0 => {
                                let e = {
                                    let l3 = *ptr1.add(8).cast::<i64>();
                                    l3 as u64
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l4 = i32::from(*ptr1.add(8).cast::<u8>());
                                    ErrorCode::_lift(l4 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Read directory entries from a directory.
                ///
                /// On filesystems where directories contain entries referring to themselves
                /// and their parents, often named `.` and `..` respectively, these entries
                /// are omitted.
                ///
                /// This always returns a new stream which starts at the beginning of the
                /// directory. Multiple streams may be active on the same directory, and they
                /// do not interfere with each other.
                pub fn read_directory(&self) -> Result<DirectoryEntryStream, 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:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.read-directory"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<i32>();
                                    DirectoryEntryStream::from_handle(l2 as u32)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = i32::from(*ptr0.add(4).cast::<u8>());
                                    ErrorCode::_lift(l3 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Synchronize the data and metadata of a file to disk.
                ///
                /// This function succeeds with no effect if the file descriptor is not
                /// opened for writing.
                ///
                /// Note: This is similar to `fsync` in POSIX.
                pub fn sync(&self) -> Result<(), ErrorCode> {
                    unsafe {
                        #[repr(align(1))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.sync"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(1).cast::<u8>());
                                    ErrorCode::_lift(l2 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Create a directory.
                ///
                /// Note: This is similar to `mkdirat` in POSIX.
                pub fn create_directory_at(&self, path: &str) -> Result<(), ErrorCode> {
                    unsafe {
                        #[repr(align(1))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2],
                        );
                        let vec0 = path;
                        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:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.create-directory-at"]
                            fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0.cast_mut(), len0, ptr1);
                        let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                        match l2 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = i32::from(*ptr1.add(1).cast::<u8>());
                                    ErrorCode::_lift(l3 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Return the attributes of an open file or directory.
                ///
                /// Note: This is similar to `fstat` in POSIX, except that it does not return
                /// device and inode information. For testing whether two descriptors refer to
                /// the same underlying filesystem object, use `is-same-object`. To obtain
                /// additional data that can be used do determine whether a file has been
                /// modified, use `metadata-hash`.
                ///
                /// Note: This was called `fd_filestat_get` in earlier versions of WASI.
                pub fn stat(&self) -> Result<DescriptorStat, ErrorCode> {
                    unsafe {
                        #[repr(align(8))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 104]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 104],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.stat"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(8).cast::<u8>());
                                    let l3 = *ptr0.add(16).cast::<i64>();
                                    let l4 = *ptr0.add(24).cast::<i64>();
                                    let l5 = i32::from(*ptr0.add(32).cast::<u8>());
                                    let l8 = i32::from(*ptr0.add(56).cast::<u8>());
                                    let l11 = i32::from(*ptr0.add(80).cast::<u8>());
                                    DescriptorStat {
                                        type_: DescriptorType::_lift(l2 as u8),
                                        link_count: l3 as u64,
                                        size: l4 as u64,
                                        data_access_timestamp: match l5 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l6 = *ptr0.add(40).cast::<i64>();
                                                    let l7 = *ptr0.add(48).cast::<i32>();
                                                    super::super::super::wasi::clocks::wall_clock::Datetime {
                                                        seconds: l6 as u64,
                                                        nanoseconds: l7 as u32,
                                                    }
                                                };
                                                Some(e)
                                            }
                                            _ => _rt::invalid_enum_discriminant(),
                                        },
                                        data_modification_timestamp: match l8 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l9 = *ptr0.add(64).cast::<i64>();
                                                    let l10 = *ptr0.add(72).cast::<i32>();
                                                    super::super::super::wasi::clocks::wall_clock::Datetime {
                                                        seconds: l9 as u64,
                                                        nanoseconds: l10 as u32,
                                                    }
                                                };
                                                Some(e)
                                            }
                                            _ => _rt::invalid_enum_discriminant(),
                                        },
                                        status_change_timestamp: match l11 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l12 = *ptr0.add(88).cast::<i64>();
                                                    let l13 = *ptr0.add(96).cast::<i32>();
                                                    super::super::super::wasi::clocks::wall_clock::Datetime {
                                                        seconds: l12 as u64,
                                                        nanoseconds: l13 as u32,
                                                    }
                                                };
                                                Some(e)
                                            }
                                            _ => _rt::invalid_enum_discriminant(),
                                        },
                                    }
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l14 = i32::from(*ptr0.add(8).cast::<u8>());
                                    ErrorCode::_lift(l14 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Return the attributes of a file or directory.
                ///
                /// Note: This is similar to `fstatat` in POSIX, except that it does not
                /// return device and inode information. See the `stat` description for a
                /// discussion of alternatives.
                ///
                /// Note: This was called `path_filestat_get` in earlier versions of WASI.
                pub fn stat_at(
                    &self,
                    path_flags: PathFlags,
                    path: &str,
                ) -> Result<DescriptorStat, ErrorCode> {
                    unsafe {
                        #[repr(align(8))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 104]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 104],
                        );
                        let flags0 = path_flags;
                        let vec1 = path;
                        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:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.stat-at"]
                            fn wit_import(
                                _: i32,
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i32, _: *mut u8, _: usize, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            (flags0.bits() >> 0) as i32,
                            ptr1.cast_mut(),
                            len1,
                            ptr2,
                        );
                        let l3 = i32::from(*ptr2.add(0).cast::<u8>());
                        match l3 {
                            0 => {
                                let e = {
                                    let l4 = i32::from(*ptr2.add(8).cast::<u8>());
                                    let l5 = *ptr2.add(16).cast::<i64>();
                                    let l6 = *ptr2.add(24).cast::<i64>();
                                    let l7 = i32::from(*ptr2.add(32).cast::<u8>());
                                    let l10 = i32::from(*ptr2.add(56).cast::<u8>());
                                    let l13 = i32::from(*ptr2.add(80).cast::<u8>());
                                    DescriptorStat {
                                        type_: DescriptorType::_lift(l4 as u8),
                                        link_count: l5 as u64,
                                        size: l6 as u64,
                                        data_access_timestamp: match l7 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l8 = *ptr2.add(40).cast::<i64>();
                                                    let l9 = *ptr2.add(48).cast::<i32>();
                                                    super::super::super::wasi::clocks::wall_clock::Datetime {
                                                        seconds: l8 as u64,
                                                        nanoseconds: l9 as u32,
                                                    }
                                                };
                                                Some(e)
                                            }
                                            _ => _rt::invalid_enum_discriminant(),
                                        },
                                        data_modification_timestamp: match l10 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l11 = *ptr2.add(64).cast::<i64>();
                                                    let l12 = *ptr2.add(72).cast::<i32>();
                                                    super::super::super::wasi::clocks::wall_clock::Datetime {
                                                        seconds: l11 as u64,
                                                        nanoseconds: l12 as u32,
                                                    }
                                                };
                                                Some(e)
                                            }
                                            _ => _rt::invalid_enum_discriminant(),
                                        },
                                        status_change_timestamp: match l13 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l14 = *ptr2.add(88).cast::<i64>();
                                                    let l15 = *ptr2.add(96).cast::<i32>();
                                                    super::super::super::wasi::clocks::wall_clock::Datetime {
                                                        seconds: l14 as u64,
                                                        nanoseconds: l15 as u32,
                                                    }
                                                };
                                                Some(e)
                                            }
                                            _ => _rt::invalid_enum_discriminant(),
                                        },
                                    }
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l16 = i32::from(*ptr2.add(8).cast::<u8>());
                                    ErrorCode::_lift(l16 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Adjust the timestamps of a file or directory.
                ///
                /// Note: This is similar to `utimensat` in POSIX.
                ///
                /// Note: This was called `path_filestat_set_times` in earlier versions of
                /// WASI.
                pub fn set_times_at(
                    &self,
                    path_flags: PathFlags,
                    path: &str,
                    data_access_timestamp: NewTimestamp,
                    data_modification_timestamp: NewTimestamp,
                ) -> Result<(), ErrorCode> {
                    unsafe {
                        #[repr(align(1))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2],
                        );
                        let flags0 = path_flags;
                        let vec1 = path;
                        let ptr1 = vec1.as_ptr().cast::<u8>();
                        let len1 = vec1.len();
                        let (result3_0, result3_1, result3_2) = match data_access_timestamp {
                            NewTimestamp::NoChange => (0i32, 0i64, 0i32),
                            NewTimestamp::Now => (1i32, 0i64, 0i32),
                            NewTimestamp::Timestamp(e) => {
                                let super::super::super::wasi::clocks::wall_clock::Datetime {
                                    seconds: seconds2,
                                    nanoseconds: nanoseconds2,
                                } = e;
                                (2i32, _rt::as_i64(seconds2), _rt::as_i32(nanoseconds2))
                            }
                        };
                        let (result5_0, result5_1, result5_2) = match data_modification_timestamp {
                            NewTimestamp::NoChange => (0i32, 0i64, 0i32),
                            NewTimestamp::Now => (1i32, 0i64, 0i32),
                            NewTimestamp::Timestamp(e) => {
                                let super::super::super::wasi::clocks::wall_clock::Datetime {
                                    seconds: seconds4,
                                    nanoseconds: nanoseconds4,
                                } = e;
                                (2i32, _rt::as_i64(seconds4), _rt::as_i32(nanoseconds4))
                            }
                        };
                        let ptr6 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.set-times-at"]
                            fn wit_import(
                                _: i32,
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: i32,
                                _: i64,
                                _: i32,
                                _: i32,
                                _: i64,
                                _: i32,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: i32,
                            _: i64,
                            _: i32,
                            _: i32,
                            _: i64,
                            _: i32,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            (flags0.bits() >> 0) as i32,
                            ptr1.cast_mut(),
                            len1,
                            result3_0,
                            result3_1,
                            result3_2,
                            result5_0,
                            result5_1,
                            result5_2,
                            ptr6,
                        );
                        let l7 = i32::from(*ptr6.add(0).cast::<u8>());
                        match l7 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l8 = i32::from(*ptr6.add(1).cast::<u8>());
                                    ErrorCode::_lift(l8 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Create a hard link.
                ///
                /// Note: This is similar to `linkat` in POSIX.
                pub fn link_at(
                    &self,
                    old_path_flags: PathFlags,
                    old_path: &str,
                    new_descriptor: &Descriptor,
                    new_path: &str,
                ) -> Result<(), ErrorCode> {
                    unsafe {
                        #[repr(align(1))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2],
                        );
                        let flags0 = old_path_flags;
                        let vec1 = old_path;
                        let ptr1 = vec1.as_ptr().cast::<u8>();
                        let len1 = vec1.len();
                        let vec2 = new_path;
                        let ptr2 = vec2.as_ptr().cast::<u8>();
                        let len2 = vec2.len();
                        let ptr3 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.link-at"]
                            fn wit_import(
                                _: i32,
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            (flags0.bits() >> 0) as i32,
                            ptr1.cast_mut(),
                            len1,
                            (new_descriptor).handle() as i32,
                            ptr2.cast_mut(),
                            len2,
                            ptr3,
                        );
                        let l4 = i32::from(*ptr3.add(0).cast::<u8>());
                        match l4 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l5 = i32::from(*ptr3.add(1).cast::<u8>());
                                    ErrorCode::_lift(l5 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Open a file or directory.
                ///
                /// The returned descriptor is not guaranteed to be the lowest-numbered
                /// descriptor not currently open/ it is randomized to prevent applications
                /// from depending on making assumptions about indexes, since this is
                /// error-prone in multi-threaded contexts. The returned descriptor is
                /// guaranteed to be less than 2**31.
                ///
                /// If `flags` contains `descriptor-flags::mutate-directory`, and the base
                /// descriptor doesn't have `descriptor-flags::mutate-directory` set,
                /// `open-at` fails with `error-code::read-only`.
                ///
                /// If `flags` contains `write` or `mutate-directory`, or `open-flags`
                /// contains `truncate` or `create`, and the base descriptor doesn't have
                /// `descriptor-flags::mutate-directory` set, `open-at` fails with
                /// `error-code::read-only`.
                ///
                /// Note: This is similar to `openat` in POSIX.
                pub fn open_at(
                    &self,
                    path_flags: PathFlags,
                    path: &str,
                    open_flags: OpenFlags,
                    flags: DescriptorFlags,
                ) -> Result<Descriptor, ErrorCode> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 8],
                        );
                        let flags0 = path_flags;
                        let vec1 = path;
                        let ptr1 = vec1.as_ptr().cast::<u8>();
                        let len1 = vec1.len();
                        let flags2 = open_flags;
                        let flags3 = flags;
                        let ptr4 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.open-at"]
                            fn wit_import(
                                _: i32,
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: i32,
                                _: i32,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: i32,
                            _: i32,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            (flags0.bits() >> 0) as i32,
                            ptr1.cast_mut(),
                            len1,
                            (flags2.bits() >> 0) as i32,
                            (flags3.bits() >> 0) as i32,
                            ptr4,
                        );
                        let l5 = i32::from(*ptr4.add(0).cast::<u8>());
                        match l5 {
                            0 => {
                                let e = {
                                    let l6 = *ptr4.add(4).cast::<i32>();
                                    Descriptor::from_handle(l6 as u32)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l7 = i32::from(*ptr4.add(4).cast::<u8>());
                                    ErrorCode::_lift(l7 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Read the contents of a symbolic link.
                ///
                /// If the contents contain an absolute or rooted path in the underlying
                /// filesystem, this function fails with `error-code::not-permitted`.
                ///
                /// Note: This is similar to `readlinkat` in POSIX.
                pub fn readlink_at(&self, path: &str) -> Result<_rt::String, ErrorCode> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let vec0 = path;
                        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:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.readlink-at"]
                            fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0.cast_mut(), len0, ptr1);
                        let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                        match l2 {
                            0 => {
                                let e = {
                                    let l3 = *ptr1.add(4).cast::<*mut u8>();
                                    let l4 = *ptr1.add(8).cast::<usize>();
                                    let len5 = l4;
                                    let bytes5 = _rt::Vec::from_raw_parts(
                                        l3.cast(),
                                        len5,
                                        len5,
                                    );
                                    _rt::string_lift(bytes5)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l6 = i32::from(*ptr1.add(4).cast::<u8>());
                                    ErrorCode::_lift(l6 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Remove a directory.
                ///
                /// Return `error-code::not-empty` if the directory is not empty.
                ///
                /// Note: This is similar to `unlinkat(fd, path, AT_REMOVEDIR)` in POSIX.
                pub fn remove_directory_at(&self, path: &str) -> Result<(), ErrorCode> {
                    unsafe {
                        #[repr(align(1))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2],
                        );
                        let vec0 = path;
                        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:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.remove-directory-at"]
                            fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0.cast_mut(), len0, ptr1);
                        let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                        match l2 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = i32::from(*ptr1.add(1).cast::<u8>());
                                    ErrorCode::_lift(l3 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Rename a filesystem object.
                ///
                /// Note: This is similar to `renameat` in POSIX.
                pub fn rename_at(
                    &self,
                    old_path: &str,
                    new_descriptor: &Descriptor,
                    new_path: &str,
                ) -> Result<(), ErrorCode> {
                    unsafe {
                        #[repr(align(1))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2],
                        );
                        let vec0 = old_path;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let vec1 = new_path;
                        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:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.rename-at"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            (new_descriptor).handle() as i32,
                            ptr1.cast_mut(),
                            len1,
                            ptr2,
                        );
                        let l3 = i32::from(*ptr2.add(0).cast::<u8>());
                        match l3 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l4 = i32::from(*ptr2.add(1).cast::<u8>());
                                    ErrorCode::_lift(l4 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Create a symbolic link (also known as a "symlink").
                ///
                /// If `old-path` starts with `/`, the function fails with
                /// `error-code::not-permitted`.
                ///
                /// Note: This is similar to `symlinkat` in POSIX.
                pub fn symlink_at(
                    &self,
                    old_path: &str,
                    new_path: &str,
                ) -> Result<(), ErrorCode> {
                    unsafe {
                        #[repr(align(1))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2],
                        );
                        let vec0 = old_path;
                        let ptr0 = vec0.as_ptr().cast::<u8>();
                        let len0 = vec0.len();
                        let vec1 = new_path;
                        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:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.symlink-at"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            ptr1.cast_mut(),
                            len1,
                            ptr2,
                        );
                        let l3 = i32::from(*ptr2.add(0).cast::<u8>());
                        match l3 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l4 = i32::from(*ptr2.add(1).cast::<u8>());
                                    ErrorCode::_lift(l4 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Unlink a filesystem object that is not a directory.
                ///
                /// Return `error-code::is-directory` if the path refers to a directory.
                /// Note: This is similar to `unlinkat(fd, path, 0)` in POSIX.
                pub fn unlink_file_at(&self, path: &str) -> Result<(), ErrorCode> {
                    unsafe {
                        #[repr(align(1))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 2],
                        );
                        let vec0 = path;
                        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:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.unlink-file-at"]
                            fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0.cast_mut(), len0, ptr1);
                        let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                        match l2 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = i32::from(*ptr1.add(1).cast::<u8>());
                                    ErrorCode::_lift(l3 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Test whether two descriptors refer to the same filesystem object.
                ///
                /// In POSIX, this corresponds to testing whether the two descriptors have the
                /// same device (`st_dev`) and inode (`st_ino` or `d_ino`) numbers.
                /// wasi-filesystem does not expose device and inode numbers, so this function
                /// may be used instead.
                pub fn is_same_object(&self, other: &Descriptor) -> bool {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.is-same-object"]
                            fn wit_import(_: i32, _: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import(
                            (self).handle() as i32,
                            (other).handle() as i32,
                        );
                        _rt::bool_lift(ret as u8)
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Return a hash of the metadata associated with a filesystem object referred
                /// to by a descriptor.
                ///
                /// This returns a hash of the last-modification timestamp and file size, and
                /// may also include the inode number, device number, birth timestamp, and
                /// other metadata fields that may change when the file is modified or
                /// replaced. It may also include a secret value chosen by the
                /// implementation and not otherwise exposed.
                ///
                /// Implementations are encourated to provide the following properties:
                ///
                /// - If the file is not modified or replaced, the computed hash value should
                /// usually not change.
                /// - If the object is modified or replaced, the computed hash value should
                /// usually change.
                /// - The inputs to the hash should not be easily computable from the
                /// computed hash.
                ///
                /// However, none of these is required.
                pub fn metadata_hash(&self) -> Result<MetadataHashValue, ErrorCode> {
                    unsafe {
                        #[repr(align(8))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 24]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 24],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.metadata-hash"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(8).cast::<i64>();
                                    let l3 = *ptr0.add(16).cast::<i64>();
                                    MetadataHashValue {
                                        lower: l2 as u64,
                                        upper: l3 as u64,
                                    }
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l4 = i32::from(*ptr0.add(8).cast::<u8>());
                                    ErrorCode::_lift(l4 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Descriptor {
                #[allow(unused_unsafe, clippy::all)]
                /// Return a hash of the metadata associated with a filesystem object referred
                /// to by a directory descriptor and a relative path.
                ///
                /// This performs the same hash computation as `metadata-hash`.
                pub fn metadata_hash_at(
                    &self,
                    path_flags: PathFlags,
                    path: &str,
                ) -> Result<MetadataHashValue, ErrorCode> {
                    unsafe {
                        #[repr(align(8))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 24]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 24],
                        );
                        let flags0 = path_flags;
                        let vec1 = path;
                        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:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]descriptor.metadata-hash-at"]
                            fn wit_import(
                                _: i32,
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i32, _: *mut u8, _: usize, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            (flags0.bits() >> 0) as i32,
                            ptr1.cast_mut(),
                            len1,
                            ptr2,
                        );
                        let l3 = i32::from(*ptr2.add(0).cast::<u8>());
                        match l3 {
                            0 => {
                                let e = {
                                    let l4 = *ptr2.add(8).cast::<i64>();
                                    let l5 = *ptr2.add(16).cast::<i64>();
                                    MetadataHashValue {
                                        lower: l4 as u64,
                                        upper: l5 as u64,
                                    }
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l6 = i32::from(*ptr2.add(8).cast::<u8>());
                                    ErrorCode::_lift(l6 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl DirectoryEntryStream {
                #[allow(unused_unsafe, clippy::all)]
                /// Read a single directory entry from a `directory-entry-stream`.
                pub fn read_directory_entry(
                    &self,
                ) -> Result<Option<DirectoryEntry>, ErrorCode> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 20]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 20],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]directory-entry-stream.read-directory-entry"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(4).cast::<u8>());
                                    match l2 {
                                        0 => None,
                                        1 => {
                                            let e = {
                                                let l3 = i32::from(*ptr0.add(8).cast::<u8>());
                                                let l4 = *ptr0.add(12).cast::<*mut u8>();
                                                let l5 = *ptr0.add(16).cast::<usize>();
                                                let len6 = l5;
                                                let bytes6 = _rt::Vec::from_raw_parts(
                                                    l4.cast(),
                                                    len6,
                                                    len6,
                                                );
                                                DirectoryEntry {
                                                    type_: DescriptorType::_lift(l3 as u8),
                                                    name: _rt::string_lift(bytes6),
                                                }
                                            };
                                            Some(e)
                                        }
                                        _ => _rt::invalid_enum_discriminant(),
                                    }
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l7 = i32::from(*ptr0.add(4).cast::<u8>());
                                    ErrorCode::_lift(l7 as u8)
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Attempts to extract a filesystem-related `error-code` from the stream
            /// `error` provided.
            ///
            /// Stream operations which return `stream-error::last-operation-failed`
            /// have a payload with more information about the operation that failed.
            /// This payload can be passed through to this function to see if there's
            /// filesystem-related information about the error to return.
            ///
            /// Note that this function is fallible because not all stream-related
            /// errors are filesystem-related errors.
            pub fn filesystem_error_code(err: &Error) -> Option<ErrorCode> {
                unsafe {
                    #[repr(align(1))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 2]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 2]);
                    let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "wasi:filesystem/types@0.2.0")]
                    extern "C" {
                        #[link_name = "filesystem-error-code"]
                        fn wit_import(_: i32, _: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i32, _: *mut u8) {
                        unreachable!()
                    }
                    wit_import((err).handle() as i32, ptr0);
                    let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                    match l1 {
                        0 => None,
                        1 => {
                            let e = {
                                let l2 = i32::from(*ptr0.add(1).cast::<u8>());
                                ErrorCode::_lift(l2 as u8)
                            };
                            Some(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
        }
        #[allow(dead_code, clippy::all)]
        pub mod preopens {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            use super::super::super::_rt;
            pub type Descriptor = super::super::super::wasi::filesystem::types::Descriptor;
            #[allow(unused_unsafe, clippy::all)]
            /// Return the set of preopened directories, and their path.
            pub fn get_directories() -> _rt::Vec<(Descriptor, _rt::String)> {
                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:filesystem/preopens@0.2.0")]
                    extern "C" {
                        #[link_name = "get-directories"]
                        fn wit_import(_: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: *mut u8) {
                        unreachable!()
                    }
                    wit_import(ptr0);
                    let l1 = *ptr0.add(0).cast::<*mut u8>();
                    let l2 = *ptr0.add(4).cast::<usize>();
                    let base7 = l1;
                    let len7 = l2;
                    let mut result7 = _rt::Vec::with_capacity(len7);
                    for i in 0..len7 {
                        let base = base7.add(i * 12);
                        let e7 = {
                            let l3 = *base.add(0).cast::<i32>();
                            let l4 = *base.add(4).cast::<*mut u8>();
                            let l5 = *base.add(8).cast::<usize>();
                            let len6 = l5;
                            let bytes6 = _rt::Vec::from_raw_parts(l4.cast(), len6, len6);
                            (
                                super::super::super::wasi::filesystem::types::Descriptor::from_handle(
                                    l3 as u32,
                                ),
                                _rt::string_lift(bytes6),
                            )
                        };
                        result7.push(e7);
                    }
                    _rt::cabi_dealloc(base7, len7 * 12, 4);
                    result7
                }
            }
        }
    }
    pub mod http {
        /// This interface defines all of the types and methods for implementing
        /// HTTP Requests and Responses, both incoming and outgoing, as well as
        /// their headers, trailers, and bodies.
        #[allow(dead_code, 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::wasi::clocks::monotonic_clock::Duration;
            pub type InputStream = super::super::super::wasi::io::streams::InputStream;
            pub type OutputStream = super::super::super::wasi::io::streams::OutputStream;
            pub type IoError = super::super::super::wasi::io::error::Error;
            pub type Pollable = super::super::super::wasi::io::poll::Pollable;
            /// 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 std::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-key` 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-key` 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 std::error::Error for HeaderError {}
            /// Field keys are always strings.
            pub type FieldKey = _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,
            /// `incoming-request.headers`, `outgoing-request.headers`) might be be
            /// immutable. In an immutable fields, the `set`, `append`, and `delete`
            /// operations will fail with `header-error.immutable`.
            #[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: _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(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]fields"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            /// Headers is an alias for Fields.
            pub type Headers = Fields;
            /// Trailers is an alias for Fields.
            pub type Trailers = Fields;
            /// Represents an incoming HTTP Request.
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct IncomingRequest {
                handle: _rt::Resource<IncomingRequest>,
            }
            impl IncomingRequest {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 IncomingRequest {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]incoming-request"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            /// Represents an outgoing HTTP Request.
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct OutgoingRequest {
                handle: _rt::Resource<OutgoingRequest>,
            }
            impl OutgoingRequest {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 OutgoingRequest {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]outgoing-request"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            /// 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 a
            /// blocking call to `wasi:io/poll.poll`.
            #[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: _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(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]request-options"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            /// Represents the ability to send an HTTP Response.
            ///
            /// This resource is used by the `wasi:http/incoming-handler` interface to
            /// allow a Response to be sent corresponding to the Request provided as the
            /// other argument to `incoming-handler.handle`.
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct ResponseOutparam {
                handle: _rt::Resource<ResponseOutparam>,
            }
            impl ResponseOutparam {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 ResponseOutparam {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]response-outparam"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            /// This type corresponds to the HTTP standard Status Code.
            pub type StatusCode = u16;
            /// Represents an incoming HTTP Response.
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct IncomingResponse {
                handle: _rt::Resource<IncomingResponse>,
            }
            impl IncomingResponse {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 IncomingResponse {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]incoming-response"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            /// Represents an incoming HTTP Request or Response's Body.
            ///
            /// A body has both its contents - a stream of bytes - and a (possibly
            /// empty) set of trailers, indicating that the full contents of the
            /// body have been received. This resource represents the contents as
            /// an `input-stream` and the delivery of trailers as a `future-trailers`,
            /// and ensures that the user of this interface may only be consuming either
            /// the body contents or waiting on trailers at any given time.
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct IncomingBody {
                handle: _rt::Resource<IncomingBody>,
            }
            impl IncomingBody {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 IncomingBody {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]incoming-body"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            /// Represents a future which may eventaully return trailers, or an error.
            ///
            /// In the case that the incoming HTTP Request or Response did not have any
            /// trailers, this future will resolve to the empty set of trailers once the
            /// complete Request or Response body has been received.
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct FutureTrailers {
                handle: _rt::Resource<FutureTrailers>,
            }
            impl FutureTrailers {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 FutureTrailers {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]future-trailers"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            /// Represents an outgoing HTTP Response.
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct OutgoingResponse {
                handle: _rt::Resource<OutgoingResponse>,
            }
            impl OutgoingResponse {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 OutgoingResponse {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]outgoing-response"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            /// Represents an outgoing HTTP Request or Response's Body.
            ///
            /// A body has both its contents - a stream of bytes - and a (possibly
            /// empty) set of trailers, inducating the full contents of the body
            /// have been sent. This resource represents the contents as an
            /// `output-stream` child resource, and the completion of the body (with
            /// optional trailers) with a static function that consumes the
            /// `outgoing-body` resource, and ensures that the user of this interface
            /// may not write to the body contents after the body has been finished.
            ///
            /// If the user code drops this resource, as opposed to calling the static
            /// method `finish`, the implementation should treat the body as incomplete,
            /// and that an error has occured. The implementation should propogate this
            /// error to the HTTP protocol by whatever means it has available,
            /// including: corrupting the body on the wire, aborting the associated
            /// Request, or sending a late status code for the Response.
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct OutgoingBody {
                handle: _rt::Resource<OutgoingBody>,
            }
            impl OutgoingBody {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 OutgoingBody {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]outgoing-body"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            /// Represents a future which may eventaully return an incoming HTTP
            /// Response, or an error.
            ///
            /// This resource is returned by the `wasi:http/outgoing-handler` interface to
            /// provide the HTTP Response corresponding to the sent Request.
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct FutureIncomingResponse {
                handle: _rt::Resource<FutureIncomingResponse>,
            }
            impl FutureIncomingResponse {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 FutureIncomingResponse {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]future-incoming-response"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Attempts to extract a http-related `error` from the wasi:io `error`
            /// provided.
            ///
            /// Stream operations which return
            /// `wasi:io/stream/stream-error::last-operation-failed` have a payload of
            /// type `wasi:io/error/error` with more information about the operation
            /// that failed. This payload can be passed through to this function to see
            /// if there's http-related information about the error to return.
            ///
            /// Note that this function is fallible because not all io-errors are
            /// http-related errors.
            pub fn http_error_code(err: &IoError) -> Option<ErrorCode> {
                unsafe {
                    #[repr(align(8))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 40]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 40]);
                    let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                    extern "C" {
                        #[link_name = "http-error-code"]
                        fn wit_import(_: i32, _: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i32, _: *mut u8) {
                        unreachable!()
                    }
                    wit_import((err).handle() as i32, ptr0);
                    let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                    match l1 {
                        0 => None,
                        1 => {
                            let e = {
                                let l2 = i32::from(*ptr0.add(8).cast::<u8>());
                                let v64 = match l2 {
                                    0 => ErrorCode::DnsTimeout,
                                    1 => {
                                        let e64 = {
                                            let l3 = i32::from(*ptr0.add(16).cast::<u8>());
                                            let l7 = i32::from(*ptr0.add(28).cast::<u8>());
                                            DnsErrorPayload {
                                                rcode: match l3 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l4 = *ptr0.add(20).cast::<*mut u8>();
                                                            let l5 = *ptr0.add(24).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(*ptr0.add(30).cast::<u16>());
                                                            l8 as u16
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                },
                                            }
                                        };
                                        ErrorCode::DnsError(e64)
                                    }
                                    2 => ErrorCode::DestinationNotFound,
                                    3 => ErrorCode::DestinationUnavailable,
                                    4 => ErrorCode::DestinationIpProhibited,
                                    5 => ErrorCode::DestinationIpUnroutable,
                                    6 => ErrorCode::ConnectionRefused,
                                    7 => ErrorCode::ConnectionTerminated,
                                    8 => ErrorCode::ConnectionTimeout,
                                    9 => ErrorCode::ConnectionReadTimeout,
                                    10 => ErrorCode::ConnectionWriteTimeout,
                                    11 => ErrorCode::ConnectionLimitReached,
                                    12 => ErrorCode::TlsProtocolError,
                                    13 => ErrorCode::TlsCertificateError,
                                    14 => {
                                        let e64 = {
                                            let l9 = i32::from(*ptr0.add(16).cast::<u8>());
                                            let l11 = i32::from(*ptr0.add(20).cast::<u8>());
                                            TlsAlertReceivedPayload {
                                                alert_id: match l9 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l10 = i32::from(*ptr0.add(17).cast::<u8>());
                                                            l10 as u8
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                },
                                                alert_message: match l11 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l12 = *ptr0.add(24).cast::<*mut u8>();
                                                            let l13 = *ptr0.add(28).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(),
                                                },
                                            }
                                        };
                                        ErrorCode::TlsAlertReceived(e64)
                                    }
                                    15 => ErrorCode::HttpRequestDenied,
                                    16 => ErrorCode::HttpRequestLengthRequired,
                                    17 => {
                                        let e64 = {
                                            let l15 = i32::from(*ptr0.add(16).cast::<u8>());
                                            match l15 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l16 = *ptr0.add(24).cast::<i64>();
                                                        l16 as u64
                                                    };
                                                    Some(e)
                                                }
                                                _ => _rt::invalid_enum_discriminant(),
                                            }
                                        };
                                        ErrorCode::HttpRequestBodySize(e64)
                                    }
                                    18 => ErrorCode::HttpRequestMethodInvalid,
                                    19 => ErrorCode::HttpRequestUriInvalid,
                                    20 => ErrorCode::HttpRequestUriTooLong,
                                    21 => {
                                        let e64 = {
                                            let l17 = i32::from(*ptr0.add(16).cast::<u8>());
                                            match l17 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l18 = *ptr0.add(20).cast::<i32>();
                                                        l18 as u32
                                                    };
                                                    Some(e)
                                                }
                                                _ => _rt::invalid_enum_discriminant(),
                                            }
                                        };
                                        ErrorCode::HttpRequestHeaderSectionSize(e64)
                                    }
                                    22 => {
                                        let e64 = {
                                            let l19 = i32::from(*ptr0.add(16).cast::<u8>());
                                            match l19 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l20 = i32::from(*ptr0.add(20).cast::<u8>());
                                                        let l24 = i32::from(*ptr0.add(32).cast::<u8>());
                                                        FieldSizePayload {
                                                            field_name: match l20 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l21 = *ptr0.add(24).cast::<*mut u8>();
                                                                        let l22 = *ptr0.add(28).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 = *ptr0.add(36).cast::<i32>();
                                                                        l25 as u32
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                        }
                                                    };
                                                    Some(e)
                                                }
                                                _ => _rt::invalid_enum_discriminant(),
                                            }
                                        };
                                        ErrorCode::HttpRequestHeaderSize(e64)
                                    }
                                    23 => {
                                        let e64 = {
                                            let l26 = i32::from(*ptr0.add(16).cast::<u8>());
                                            match l26 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l27 = *ptr0.add(20).cast::<i32>();
                                                        l27 as u32
                                                    };
                                                    Some(e)
                                                }
                                                _ => _rt::invalid_enum_discriminant(),
                                            }
                                        };
                                        ErrorCode::HttpRequestTrailerSectionSize(e64)
                                    }
                                    24 => {
                                        let e64 = {
                                            let l28 = i32::from(*ptr0.add(16).cast::<u8>());
                                            let l32 = i32::from(*ptr0.add(28).cast::<u8>());
                                            FieldSizePayload {
                                                field_name: match l28 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l29 = *ptr0.add(20).cast::<*mut u8>();
                                                            let l30 = *ptr0.add(24).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 = *ptr0.add(32).cast::<i32>();
                                                            l33 as u32
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                },
                                            }
                                        };
                                        ErrorCode::HttpRequestTrailerSize(e64)
                                    }
                                    25 => ErrorCode::HttpResponseIncomplete,
                                    26 => {
                                        let e64 = {
                                            let l34 = i32::from(*ptr0.add(16).cast::<u8>());
                                            match l34 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l35 = *ptr0.add(20).cast::<i32>();
                                                        l35 as u32
                                                    };
                                                    Some(e)
                                                }
                                                _ => _rt::invalid_enum_discriminant(),
                                            }
                                        };
                                        ErrorCode::HttpResponseHeaderSectionSize(e64)
                                    }
                                    27 => {
                                        let e64 = {
                                            let l36 = i32::from(*ptr0.add(16).cast::<u8>());
                                            let l40 = i32::from(*ptr0.add(28).cast::<u8>());
                                            FieldSizePayload {
                                                field_name: match l36 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l37 = *ptr0.add(20).cast::<*mut u8>();
                                                            let l38 = *ptr0.add(24).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 = *ptr0.add(32).cast::<i32>();
                                                            l41 as u32
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                },
                                            }
                                        };
                                        ErrorCode::HttpResponseHeaderSize(e64)
                                    }
                                    28 => {
                                        let e64 = {
                                            let l42 = i32::from(*ptr0.add(16).cast::<u8>());
                                            match l42 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l43 = *ptr0.add(24).cast::<i64>();
                                                        l43 as u64
                                                    };
                                                    Some(e)
                                                }
                                                _ => _rt::invalid_enum_discriminant(),
                                            }
                                        };
                                        ErrorCode::HttpResponseBodySize(e64)
                                    }
                                    29 => {
                                        let e64 = {
                                            let l44 = i32::from(*ptr0.add(16).cast::<u8>());
                                            match l44 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l45 = *ptr0.add(20).cast::<i32>();
                                                        l45 as u32
                                                    };
                                                    Some(e)
                                                }
                                                _ => _rt::invalid_enum_discriminant(),
                                            }
                                        };
                                        ErrorCode::HttpResponseTrailerSectionSize(e64)
                                    }
                                    30 => {
                                        let e64 = {
                                            let l46 = i32::from(*ptr0.add(16).cast::<u8>());
                                            let l50 = i32::from(*ptr0.add(28).cast::<u8>());
                                            FieldSizePayload {
                                                field_name: match l46 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l47 = *ptr0.add(20).cast::<*mut u8>();
                                                            let l48 = *ptr0.add(24).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 = *ptr0.add(32).cast::<i32>();
                                                            l51 as u32
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                },
                                            }
                                        };
                                        ErrorCode::HttpResponseTrailerSize(e64)
                                    }
                                    31 => {
                                        let e64 = {
                                            let l52 = i32::from(*ptr0.add(16).cast::<u8>());
                                            match l52 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l53 = *ptr0.add(20).cast::<*mut u8>();
                                                        let l54 = *ptr0.add(24).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(),
                                            }
                                        };
                                        ErrorCode::HttpResponseTransferCoding(e64)
                                    }
                                    32 => {
                                        let e64 = {
                                            let l56 = i32::from(*ptr0.add(16).cast::<u8>());
                                            match l56 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l57 = *ptr0.add(20).cast::<*mut u8>();
                                                        let l58 = *ptr0.add(24).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(),
                                            }
                                        };
                                        ErrorCode::HttpResponseContentCoding(e64)
                                    }
                                    33 => ErrorCode::HttpResponseTimeout,
                                    34 => ErrorCode::HttpUpgradeFailed,
                                    35 => ErrorCode::HttpProtocolError,
                                    36 => ErrorCode::LoopDetected,
                                    37 => ErrorCode::ConfigurationError,
                                    n => {
                                        debug_assert_eq!(n, 38, "invalid enum discriminant");
                                        let e64 = {
                                            let l60 = i32::from(*ptr0.add(16).cast::<u8>());
                                            match l60 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l61 = *ptr0.add(20).cast::<*mut u8>();
                                                        let l62 = *ptr0.add(24).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(),
                                            }
                                        };
                                        ErrorCode::InternalError(e64)
                                    }
                                };
                                v64
                            };
                            Some(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
            impl Fields {
                #[allow(unused_unsafe, clippy::all)]
                /// Construct an empty HTTP Fields.
                ///
                /// The resulting `fields` is mutable.
                pub fn new() -> Self {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[constructor]fields"]
                            fn wit_import() -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import() -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import();
                        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 key-value pair in the Fields. Keys
                /// which have multiple values are represented by multiple entries in this
                /// list with the same key.
                ///
                /// The tuple is a pair of the field key, represented as a string, and
                /// Value, represented as a list of bytes. In a valid Fields, all keys
                /// 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.
                pub fn from_list(
                    entries: &[(FieldKey, 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_unchecked(
                            vec3.len() * 16,
                            4,
                        );
                        let result3 = if layout3.size() != 0 {
                            let ptr = _rt::alloc::alloc(layout3).cast::<u8>();
                            if ptr.is_null() {
                                _rt::alloc::handle_alloc_error(layout3);
                            }
                            ptr
                        } else {
                            ::core::ptr::null_mut()
                        };
                        for (i, e) in vec3.into_iter().enumerate() {
                            let base = result3.add(i * 16);
                            {
                                let (t0_0, t0_1) = e;
                                let vec1 = t0_0;
                                let ptr1 = vec1.as_ptr().cast::<u8>();
                                let len1 = vec1.len();
                                *base.add(4).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(12).cast::<usize>() = len2;
                                *base.add(8).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.2.0")]
                        extern "C" {
                            #[link_name = "[static]fields.from-list"]
                            fn wit_import(_: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: *mut u8, _: usize, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import(result3, len3, ptr4);
                        let l5 = i32::from(*ptr4.add(0).cast::<u8>());
                        if layout3.size() != 0 {
                            _rt::alloc::dealloc(result3.cast(), layout3);
                        }
                        match l5 {
                            0 => {
                                let e = {
                                    let l6 = *ptr4.add(4).cast::<i32>();
                                    Fields::from_handle(l6 as u32)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l7 = i32::from(*ptr4.add(4).cast::<u8>());
                                    let v8 = match l7 {
                                        0 => HeaderError::InvalidSyntax,
                                        1 => HeaderError::Forbidden,
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            HeaderError::Immutable
                                        }
                                    };
                                    v8
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Fields {
                #[allow(unused_unsafe, clippy::all)]
                /// Get all of the values corresponding to a key. If the key is not present
                /// in this `fields`, an empty list is returned. However, if the key is
                /// present but empty, this is represented by a list with one or more
                /// empty field-values present.
                pub fn get(&self, name: &FieldKey) -> _rt::Vec<FieldValue> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 8],
                        );
                        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.2.0")]
                        extern "C" {
                            #[link_name = "[method]fields.get"]
                            fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0.cast_mut(), len0, ptr1);
                        let l2 = *ptr1.add(0).cast::<*mut u8>();
                        let l3 = *ptr1.add(4).cast::<usize>();
                        let base7 = l2;
                        let len7 = l3;
                        let mut result7 = _rt::Vec::with_capacity(len7);
                        for i in 0..len7 {
                            let base = base7.add(i * 8);
                            let e7 = {
                                let l4 = *base.add(0).cast::<*mut u8>();
                                let l5 = *base.add(4).cast::<usize>();
                                let len6 = l5;
                                _rt::Vec::from_raw_parts(l4.cast(), len6, len6)
                            };
                            result7.push(e7);
                        }
                        _rt::cabi_dealloc(base7, len7 * 8, 4);
                        result7
                    }
                }
            }
            impl Fields {
                #[allow(unused_unsafe, clippy::all)]
                /// Returns `true` when the key is present in this `fields`. If the key is
                /// syntactically invalid, `false` is returned.
                pub fn has(&self, name: &FieldKey) -> 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.2.0")]
                        extern "C" {
                            #[link_name = "[method]fields.has"]
                            fn wit_import(_: i32, _: *mut u8, _: usize) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8, _: usize) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import(
                            (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 key. Clears any existing values for that
                /// key, if they have been set.
                ///
                /// Fails with `header-error.immutable` if the `fields` are immutable.
                pub fn set(
                    &self,
                    name: &FieldKey,
                    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_unchecked(
                            vec2.len() * 8,
                            4,
                        );
                        let result2 = if layout2.size() != 0 {
                            let ptr = _rt::alloc::alloc(layout2).cast::<u8>();
                            if ptr.is_null() {
                                _rt::alloc::handle_alloc_error(layout2);
                            }
                            ptr
                        } else {
                            ::core::ptr::null_mut()
                        };
                        for (i, e) in vec2.into_iter().enumerate() {
                            let base = result2.add(i * 8);
                            {
                                let vec1 = e;
                                let ptr1 = vec1.as_ptr().cast::<u8>();
                                let len1 = vec1.len();
                                *base.add(4).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.2.0")]
                        extern "C" {
                            #[link_name = "[method]fields.set"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            result2,
                            len2,
                            ptr3,
                        );
                        let l4 = i32::from(*ptr3.add(0).cast::<u8>());
                        if layout2.size() != 0 {
                            _rt::alloc::dealloc(result2.cast(), layout2);
                        }
                        match l4 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l5 = i32::from(*ptr3.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(),
                        }
                    }
                }
            }
            impl Fields {
                #[allow(unused_unsafe, clippy::all)]
                /// Delete all values for a key. Does nothing if no values for the key
                /// exist.
                ///
                /// Fails with `header-error.immutable` if the `fields` are immutable.
                pub fn delete(&self, name: &FieldKey) -> 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.2.0")]
                        extern "C" {
                            #[link_name = "[method]fields.delete"]
                            fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0.cast_mut(), len0, ptr1);
                        let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                        match l2 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = i32::from(*ptr1.add(1).cast::<u8>());
                                    let v4 = match l3 {
                                        0 => HeaderError::InvalidSyntax,
                                        1 => HeaderError::Forbidden,
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            HeaderError::Immutable
                                        }
                                    };
                                    v4
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl Fields {
                #[allow(unused_unsafe, clippy::all)]
                /// Append a value for a key. Does not change or delete any existing
                /// values for that key.
                ///
                /// Fails with `header-error.immutable` if the `fields` are immutable.
                pub fn append(
                    &self,
                    name: &FieldKey,
                    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 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.2.0")]
                        extern "C" {
                            #[link_name = "[method]fields.append"]
                            fn wit_import(
                                _: i32,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                                _: usize,
                                _: *mut u8,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            ptr0.cast_mut(),
                            len0,
                            ptr1.cast_mut(),
                            len1,
                            ptr2,
                        );
                        let l3 = i32::from(*ptr2.add(0).cast::<u8>());
                        match l3 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l4 = i32::from(*ptr2.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(),
                        }
                    }
                }
            }
            impl Fields {
                #[allow(unused_unsafe, clippy::all)]
                /// Retrieve the full set of keys and values in the Fields. Like the
                /// constructor, the list represents each key-value pair.
                ///
                /// The outer list represents each key-value pair in the Fields. Keys
                /// which have multiple values are represented by multiple entries in this
                /// list with the same key.
                pub fn entries(&self) -> _rt::Vec<(FieldKey, FieldValue)> {
                    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.2.0")]
                        extern "C" {
                            #[link_name = "[method]fields.entries"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = *ptr0.add(0).cast::<*mut u8>();
                        let l2 = *ptr0.add(4).cast::<usize>();
                        let base9 = l1;
                        let len9 = l2;
                        let mut result9 = _rt::Vec::with_capacity(len9);
                        for i in 0..len9 {
                            let base = base9.add(i * 16);
                            let e9 = {
                                let l3 = *base.add(0).cast::<*mut u8>();
                                let l4 = *base.add(4).cast::<usize>();
                                let len5 = l4;
                                let bytes5 = _rt::Vec::from_raw_parts(
                                    l3.cast(),
                                    len5,
                                    len5,
                                );
                                let l6 = *base.add(8).cast::<*mut u8>();
                                let l7 = *base.add(12).cast::<usize>();
                                let len8 = l7;
                                (
                                    _rt::string_lift(bytes5),
                                    _rt::Vec::from_raw_parts(l6.cast(), len8, len8),
                                )
                            };
                            result9.push(e9);
                        }
                        _rt::cabi_dealloc(base9, len9 * 16, 4);
                        result9
                    }
                }
            }
            impl Fields {
                #[allow(unused_unsafe, clippy::all)]
                /// Make a deep copy of the Fields. Equivelant in behavior to calling the
                /// `fields` constructor on the return value of `entries`. The resulting
                /// `fields` is mutable.
                pub fn clone(&self) -> Fields {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]fields.clone"]
                            fn wit_import(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import((self).handle() as i32);
                        Fields::from_handle(ret as u32)
                    }
                }
            }
            impl IncomingRequest {
                #[allow(unused_unsafe, clippy::all)]
                /// Returns the method of the incoming request.
                pub fn method(&self) -> Method {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]incoming-request.method"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        let v5 = match l1 {
                            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 e5 = {
                                    let l2 = *ptr0.add(4).cast::<*mut u8>();
                                    let l3 = *ptr0.add(8).cast::<usize>();
                                    let len4 = l3;
                                    let bytes4 = _rt::Vec::from_raw_parts(
                                        l2.cast(),
                                        len4,
                                        len4,
                                    );
                                    _rt::string_lift(bytes4)
                                };
                                Method::Other(e5)
                            }
                        };
                        v5
                    }
                }
            }
            impl IncomingRequest {
                #[allow(unused_unsafe, clippy::all)]
                /// Returns the path with query parameters from the request, as a string.
                pub fn path_with_query(&self) -> Option<_rt::String> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]incoming-request.path-with-query"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<*mut u8>();
                                    let l3 = *ptr0.add(8).cast::<usize>();
                                    let len4 = l3;
                                    let bytes4 = _rt::Vec::from_raw_parts(
                                        l2.cast(),
                                        len4,
                                        len4,
                                    );
                                    _rt::string_lift(bytes4)
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl IncomingRequest {
                #[allow(unused_unsafe, clippy::all)]
                /// Returns the protocol scheme from the request.
                pub fn scheme(&self) -> Option<Scheme> {
                    unsafe {
                        #[repr(align(4))]
                        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.2.0")]
                        extern "C" {
                            #[link_name = "[method]incoming-request.scheme"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(4).cast::<u8>());
                                    let v6 = match l2 {
                                        0 => Scheme::Http,
                                        1 => Scheme::Https,
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            let e6 = {
                                                let l3 = *ptr0.add(8).cast::<*mut u8>();
                                                let l4 = *ptr0.add(12).cast::<usize>();
                                                let len5 = l4;
                                                let bytes5 = _rt::Vec::from_raw_parts(
                                                    l3.cast(),
                                                    len5,
                                                    len5,
                                                );
                                                _rt::string_lift(bytes5)
                                            };
                                            Scheme::Other(e6)
                                        }
                                    };
                                    v6
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl IncomingRequest {
                #[allow(unused_unsafe, clippy::all)]
                /// Returns the authority from the request, if it was present.
                pub fn authority(&self) -> Option<_rt::String> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]incoming-request.authority"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<*mut u8>();
                                    let l3 = *ptr0.add(8).cast::<usize>();
                                    let len4 = l3;
                                    let bytes4 = _rt::Vec::from_raw_parts(
                                        l2.cast(),
                                        len4,
                                        len4,
                                    );
                                    _rt::string_lift(bytes4)
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl IncomingRequest {
                #[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`.
                ///
                /// The `headers` returned are a child resource: it must be dropped before
                /// the parent `incoming-request` is dropped. Dropping this
                /// `incoming-request` before all children are dropped will trap.
                pub fn headers(&self) -> Headers {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]incoming-request.headers"]
                            fn wit_import(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import((self).handle() as i32);
                        Fields::from_handle(ret as u32)
                    }
                }
            }
            impl IncomingRequest {
                #[allow(unused_unsafe, clippy::all)]
                /// Gives the `incoming-body` associated with this request. Will only
                /// return success at most once, and subsequent calls will return error.
                pub fn consume(&self) -> Result<IncomingBody, ()> {
                    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.2.0")]
                        extern "C" {
                            #[link_name = "[method]incoming-request.consume"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<i32>();
                                    IncomingBody::from_handle(l2 as u32)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = ();
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl OutgoingRequest {
                #[allow(unused_unsafe, clippy::all)]
                /// Construct a new `outgoing-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.
                ///
                /// It is possible to construct, or manipulate with the accessor functions
                /// below, an `outgoing-request` with an invalid combination of `scheme`
                /// and `authority`, or `headers` which are not permitted to be sent.
                /// It is the obligation of the `outgoing-handler.handle` implementation
                /// to reject invalid constructions of `outgoing-request`.
                pub fn new(headers: Headers) -> Self {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[constructor]outgoing-request"]
                            fn wit_import(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import((&headers).take_handle() as i32);
                        OutgoingRequest::from_handle(ret as u32)
                    }
                }
            }
            impl OutgoingRequest {
                #[allow(unused_unsafe, clippy::all)]
                /// Returns the resource corresponding to the outgoing Body for this
                /// Request.
                ///
                /// Returns success on the first call: the `outgoing-body` resource for
                /// this `outgoing-request` can be retrieved at most once. Subsequent
                /// calls will return error.
                pub fn body(&self) -> Result<OutgoingBody, ()> {
                    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.2.0")]
                        extern "C" {
                            #[link_name = "[method]outgoing-request.body"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<i32>();
                                    OutgoingBody::from_handle(l2 as u32)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = ();
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl OutgoingRequest {
                #[allow(unused_unsafe, clippy::all)]
                /// Get the Method for the Request.
                pub fn method(&self) -> Method {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]outgoing-request.method"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        let v5 = match l1 {
                            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 e5 = {
                                    let l2 = *ptr0.add(4).cast::<*mut u8>();
                                    let l3 = *ptr0.add(8).cast::<usize>();
                                    let len4 = l3;
                                    let bytes4 = _rt::Vec::from_raw_parts(
                                        l2.cast(),
                                        len4,
                                        len4,
                                    );
                                    _rt::string_lift(bytes4)
                                };
                                Method::Other(e5)
                            }
                        };
                        v5
                    }
                }
            }
            impl OutgoingRequest {
                #[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.
                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.2.0")]
                        extern "C" {
                            #[link_name = "[method]outgoing-request.set-method"]
                            fn wit_import(_: i32, _: i32, _: *mut u8, _: usize) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i32, _: *mut u8, _: usize) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import(
                            (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 OutgoingRequest {
                #[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.
                pub fn path_with_query(&self) -> Option<_rt::String> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]outgoing-request.path-with-query"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<*mut u8>();
                                    let l3 = *ptr0.add(8).cast::<usize>();
                                    let len4 = l3;
                                    let bytes4 = _rt::Vec::from_raw_parts(
                                        l2.cast(),
                                        len4,
                                        len4,
                                    );
                                    _rt::string_lift(bytes4)
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl OutgoingRequest {
                #[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.
                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.2.0")]
                        extern "C" {
                            #[link_name = "[method]outgoing-request.set-path-with-query"]
                            fn wit_import(_: i32, _: i32, _: *mut u8, _: usize) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i32, _: *mut u8, _: usize) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import(
                            (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 OutgoingRequest {
                #[allow(unused_unsafe, clippy::all)]
                /// Get the HTTP Related Scheme for the Request. When `none`, the
                /// implementation may choose an appropriate default scheme.
                pub fn scheme(&self) -> Option<Scheme> {
                    unsafe {
                        #[repr(align(4))]
                        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.2.0")]
                        extern "C" {
                            #[link_name = "[method]outgoing-request.scheme"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(4).cast::<u8>());
                                    let v6 = match l2 {
                                        0 => Scheme::Http,
                                        1 => Scheme::Https,
                                        n => {
                                            debug_assert_eq!(n, 2, "invalid enum discriminant");
                                            let e6 = {
                                                let l3 = *ptr0.add(8).cast::<*mut u8>();
                                                let l4 = *ptr0.add(12).cast::<usize>();
                                                let len5 = l4;
                                                let bytes5 = _rt::Vec::from_raw_parts(
                                                    l3.cast(),
                                                    len5,
                                                    len5,
                                                );
                                                _rt::string_lift(bytes5)
                                            };
                                            Scheme::Other(e6)
                                        }
                                    };
                                    v6
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl OutgoingRequest {
                #[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.
                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.2.0")]
                        extern "C" {
                            #[link_name = "[method]outgoing-request.set-scheme"]
                            fn wit_import(
                                _: i32,
                                _: i32,
                                _: i32,
                                _: *mut u8,
                                _: usize,
                            ) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: i32,
                            _: i32,
                            _: *mut u8,
                            _: usize,
                        ) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import(
                            (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 OutgoingRequest {
                #[allow(unused_unsafe, clippy::all)]
                /// Get the HTTP Authority for the Request. 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.
                pub fn authority(&self) -> Option<_rt::String> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]outgoing-request.authority"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<*mut u8>();
                                    let l3 = *ptr0.add(8).cast::<usize>();
                                    let len4 = l3;
                                    let bytes4 = _rt::Vec::from_raw_parts(
                                        l2.cast(),
                                        len4,
                                        len4,
                                    );
                                    _rt::string_lift(bytes4)
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl OutgoingRequest {
                #[allow(unused_unsafe, clippy::all)]
                /// Set the HTTP Authority for the Request. 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.
                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.2.0")]
                        extern "C" {
                            #[link_name = "[method]outgoing-request.set-authority"]
                            fn wit_import(_: i32, _: i32, _: *mut u8, _: usize) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i32, _: *mut u8, _: usize) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import(
                            (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 OutgoingRequest {
                #[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`.
                ///
                /// This headers resource is a child: it must be dropped before the parent
                /// `outgoing-request` is dropped, or its ownership is transfered to
                /// another component by e.g. `outgoing-handler.handle`.
                pub fn headers(&self) -> Headers {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]outgoing-request.headers"]
                            fn wit_import(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import((self).handle() as i32);
                        Fields::from_handle(ret as u32)
                    }
                }
            }
            impl RequestOptions {
                #[allow(unused_unsafe, clippy::all)]
                /// Construct a default `request-options` value.
                pub fn new() -> Self {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[constructor]request-options"]
                            fn wit_import() -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import() -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import();
                        RequestOptions::from_handle(ret as u32)
                    }
                }
            }
            impl RequestOptions {
                #[allow(unused_unsafe, clippy::all)]
                /// The timeout for the initial connect to the HTTP Server.
                pub fn 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.2.0")]
                        extern "C" {
                            #[link_name = "[method]request-options.connect-timeout"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l2 = *ptr0.add(8).cast::<i64>();
                                    l2 as u64
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            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.
                pub fn set_connect_timeout(
                    &self,
                    duration: Option<Duration>,
                ) -> Result<(), ()> {
                    unsafe {
                        let (result0_0, result0_1) = match duration {
                            Some(e) => (1i32, _rt::as_i64(e)),
                            None => (0i32, 0i64),
                        };
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]request-options.set-connect-timeout"]
                            fn wit_import(_: i32, _: i32, _: i64) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i32, _: i64) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import(
                            (self).handle() as i32,
                            result0_0,
                            result0_1,
                        );
                        match ret {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = ();
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl RequestOptions {
                #[allow(unused_unsafe, clippy::all)]
                /// The timeout for receiving the first byte of the Response body.
                pub fn 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.2.0")]
                        extern "C" {
                            #[link_name = "[method]request-options.first-byte-timeout"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l2 = *ptr0.add(8).cast::<i64>();
                                    l2 as u64
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            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.
                pub fn set_first_byte_timeout(
                    &self,
                    duration: Option<Duration>,
                ) -> Result<(), ()> {
                    unsafe {
                        let (result0_0, result0_1) = match duration {
                            Some(e) => (1i32, _rt::as_i64(e)),
                            None => (0i32, 0i64),
                        };
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]request-options.set-first-byte-timeout"]
                            fn wit_import(_: i32, _: i32, _: i64) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i32, _: i64) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import(
                            (self).handle() as i32,
                            result0_0,
                            result0_1,
                        );
                        match ret {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = ();
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl RequestOptions {
                #[allow(unused_unsafe, clippy::all)]
                /// The timeout for receiving subsequent chunks of bytes in the Response
                /// body stream.
                pub fn 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.2.0")]
                        extern "C" {
                            #[link_name = "[method]request-options.between-bytes-timeout"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l2 = *ptr0.add(8).cast::<i64>();
                                    l2 as u64
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            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.
                pub fn set_between_bytes_timeout(
                    &self,
                    duration: Option<Duration>,
                ) -> Result<(), ()> {
                    unsafe {
                        let (result0_0, result0_1) = match duration {
                            Some(e) => (1i32, _rt::as_i64(e)),
                            None => (0i32, 0i64),
                        };
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]request-options.set-between-bytes-timeout"]
                            fn wit_import(_: i32, _: i32, _: i64) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i32, _: i64) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import(
                            (self).handle() as i32,
                            result0_0,
                            result0_1,
                        );
                        match ret {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = ();
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl ResponseOutparam {
                #[allow(unused_unsafe, clippy::all)]
                /// Set the value of the `response-outparam` to either send a response,
                /// or indicate an error.
                ///
                /// This method consumes the `response-outparam` to ensure that it is
                /// called at most once. If it is never called, the implementation
                /// will respond with an error.
                ///
                /// The user may provide an `error` to `response` to allow the
                /// implementation determine how to respond with an HTTP error response.
                pub fn set(
                    param: ResponseOutparam,
                    response: Result<OutgoingResponse, ErrorCode>,
                ) {
                    unsafe {
                        let (
                            result38_0,
                            result38_1,
                            result38_2,
                            result38_3,
                            result38_4,
                            result38_5,
                            result38_6,
                            result38_7,
                        ) = match &response {
                            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) => {
                                let (
                                    result37_0,
                                    result37_1,
                                    result37_2,
                                    result37_3,
                                    result37_4,
                                    result37_5,
                                    result37_6,
                                ) = match e {
                                    ErrorCode::DnsTimeout => {
                                        (
                                            0i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::DnsError(e) => {
                                        let DnsErrorPayload {
                                            rcode: rcode0,
                                            info_code: info_code0,
                                        } = e;
                                        let (result2_0, result2_1, result2_2) = match rcode0 {
                                            Some(e) => {
                                                let vec1 = e;
                                                let ptr1 = vec1.as_ptr().cast::<u8>();
                                                let len1 = vec1.len();
                                                (1i32, ptr1.cast_mut(), len1)
                                            }
                                            None => (0i32, ::core::ptr::null_mut(), 0usize),
                                        };
                                        let (result3_0, result3_1) = match info_code0 {
                                            Some(e) => (1i32, _rt::as_i32(e)),
                                            None => (0i32, 0i32),
                                        };
                                        (
                                            1i32,
                                            result2_0,
                                            {
                                                let mut t = ::core::mem::MaybeUninit::<u64>::uninit();
                                                t.as_mut_ptr().cast::<*mut u8>().write(result2_1);
                                                t
                                            },
                                            result2_2 as *mut u8,
                                            result3_0 as *mut u8,
                                            result3_1 as usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::DestinationNotFound => {
                                        (
                                            2i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::DestinationUnavailable => {
                                        (
                                            3i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::DestinationIpProhibited => {
                                        (
                                            4i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::DestinationIpUnroutable => {
                                        (
                                            5i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::ConnectionRefused => {
                                        (
                                            6i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::ConnectionTerminated => {
                                        (
                                            7i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::ConnectionTimeout => {
                                        (
                                            8i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::ConnectionReadTimeout => {
                                        (
                                            9i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::ConnectionWriteTimeout => {
                                        (
                                            10i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::ConnectionLimitReached => {
                                        (
                                            11i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::TlsProtocolError => {
                                        (
                                            12i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::TlsCertificateError => {
                                        (
                                            13i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::TlsAlertReceived(e) => {
                                        let TlsAlertReceivedPayload {
                                            alert_id: alert_id4,
                                            alert_message: alert_message4,
                                        } = e;
                                        let (result5_0, result5_1) = match alert_id4 {
                                            Some(e) => (1i32, _rt::as_i32(e)),
                                            None => (0i32, 0i32),
                                        };
                                        let (result7_0, result7_1, result7_2) = match alert_message4 {
                                            Some(e) => {
                                                let vec6 = e;
                                                let ptr6 = vec6.as_ptr().cast::<u8>();
                                                let len6 = vec6.len();
                                                (1i32, ptr6.cast_mut(), len6)
                                            }
                                            None => (0i32, ::core::ptr::null_mut(), 0usize),
                                        };
                                        (
                                            14i32,
                                            result5_0,
                                            ::core::mem::MaybeUninit::new(i64::from(result5_1) as u64),
                                            result7_0 as *mut u8,
                                            result7_1,
                                            result7_2,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::HttpRequestDenied => {
                                        (
                                            15i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::HttpRequestLengthRequired => {
                                        (
                                            16i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::HttpRequestBodySize(e) => {
                                        let (result8_0, result8_1) = match e {
                                            Some(e) => (1i32, _rt::as_i64(e)),
                                            None => (0i32, 0i64),
                                        };
                                        (
                                            17i32,
                                            result8_0,
                                            ::core::mem::MaybeUninit::new(result8_1 as u64),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::HttpRequestMethodInvalid => {
                                        (
                                            18i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::HttpRequestUriInvalid => {
                                        (
                                            19i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::HttpRequestUriTooLong => {
                                        (
                                            20i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::HttpRequestHeaderSectionSize(e) => {
                                        let (result9_0, result9_1) = match e {
                                            Some(e) => (1i32, _rt::as_i32(e)),
                                            None => (0i32, 0i32),
                                        };
                                        (
                                            21i32,
                                            result9_0,
                                            ::core::mem::MaybeUninit::new(i64::from(result9_1) as u64),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::HttpRequestHeaderSize(e) => {
                                        let (
                                            result14_0,
                                            result14_1,
                                            result14_2,
                                            result14_3,
                                            result14_4,
                                            result14_5,
                                        ) = match e {
                                            Some(e) => {
                                                let FieldSizePayload {
                                                    field_name: field_name10,
                                                    field_size: field_size10,
                                                } = e;
                                                let (result12_0, result12_1, result12_2) = match field_name10 {
                                                    Some(e) => {
                                                        let vec11 = e;
                                                        let ptr11 = vec11.as_ptr().cast::<u8>();
                                                        let len11 = vec11.len();
                                                        (1i32, ptr11.cast_mut(), len11)
                                                    }
                                                    None => (0i32, ::core::ptr::null_mut(), 0usize),
                                                };
                                                let (result13_0, result13_1) = match field_size10 {
                                                    Some(e) => (1i32, _rt::as_i32(e)),
                                                    None => (0i32, 0i32),
                                                };
                                                (
                                                    1i32,
                                                    result12_0,
                                                    result12_1,
                                                    result12_2,
                                                    result13_0,
                                                    result13_1,
                                                )
                                            }
                                            None => {
                                                (0i32, 0i32, ::core::ptr::null_mut(), 0usize, 0i32, 0i32)
                                            }
                                        };
                                        (
                                            22i32,
                                            result14_0,
                                            ::core::mem::MaybeUninit::new(i64::from(result14_1) as u64),
                                            result14_2,
                                            result14_3 as *mut u8,
                                            result14_4 as usize,
                                            result14_5,
                                        )
                                    }
                                    ErrorCode::HttpRequestTrailerSectionSize(e) => {
                                        let (result15_0, result15_1) = match e {
                                            Some(e) => (1i32, _rt::as_i32(e)),
                                            None => (0i32, 0i32),
                                        };
                                        (
                                            23i32,
                                            result15_0,
                                            ::core::mem::MaybeUninit::new(i64::from(result15_1) as u64),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::HttpRequestTrailerSize(e) => {
                                        let FieldSizePayload {
                                            field_name: field_name16,
                                            field_size: field_size16,
                                        } = e;
                                        let (result18_0, result18_1, result18_2) = match field_name16 {
                                            Some(e) => {
                                                let vec17 = e;
                                                let ptr17 = vec17.as_ptr().cast::<u8>();
                                                let len17 = vec17.len();
                                                (1i32, ptr17.cast_mut(), len17)
                                            }
                                            None => (0i32, ::core::ptr::null_mut(), 0usize),
                                        };
                                        let (result19_0, result19_1) = match field_size16 {
                                            Some(e) => (1i32, _rt::as_i32(e)),
                                            None => (0i32, 0i32),
                                        };
                                        (
                                            24i32,
                                            result18_0,
                                            {
                                                let mut t = ::core::mem::MaybeUninit::<u64>::uninit();
                                                t.as_mut_ptr().cast::<*mut u8>().write(result18_1);
                                                t
                                            },
                                            result18_2 as *mut u8,
                                            result19_0 as *mut u8,
                                            result19_1 as usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::HttpResponseIncomplete => {
                                        (
                                            25i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::HttpResponseHeaderSectionSize(e) => {
                                        let (result20_0, result20_1) = match e {
                                            Some(e) => (1i32, _rt::as_i32(e)),
                                            None => (0i32, 0i32),
                                        };
                                        (
                                            26i32,
                                            result20_0,
                                            ::core::mem::MaybeUninit::new(i64::from(result20_1) as u64),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::HttpResponseHeaderSize(e) => {
                                        let FieldSizePayload {
                                            field_name: field_name21,
                                            field_size: field_size21,
                                        } = e;
                                        let (result23_0, result23_1, result23_2) = match field_name21 {
                                            Some(e) => {
                                                let vec22 = e;
                                                let ptr22 = vec22.as_ptr().cast::<u8>();
                                                let len22 = vec22.len();
                                                (1i32, ptr22.cast_mut(), len22)
                                            }
                                            None => (0i32, ::core::ptr::null_mut(), 0usize),
                                        };
                                        let (result24_0, result24_1) = match field_size21 {
                                            Some(e) => (1i32, _rt::as_i32(e)),
                                            None => (0i32, 0i32),
                                        };
                                        (
                                            27i32,
                                            result23_0,
                                            {
                                                let mut t = ::core::mem::MaybeUninit::<u64>::uninit();
                                                t.as_mut_ptr().cast::<*mut u8>().write(result23_1);
                                                t
                                            },
                                            result23_2 as *mut u8,
                                            result24_0 as *mut u8,
                                            result24_1 as usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::HttpResponseBodySize(e) => {
                                        let (result25_0, result25_1) = match e {
                                            Some(e) => (1i32, _rt::as_i64(e)),
                                            None => (0i32, 0i64),
                                        };
                                        (
                                            28i32,
                                            result25_0,
                                            ::core::mem::MaybeUninit::new(result25_1 as u64),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::HttpResponseTrailerSectionSize(e) => {
                                        let (result26_0, result26_1) = match e {
                                            Some(e) => (1i32, _rt::as_i32(e)),
                                            None => (0i32, 0i32),
                                        };
                                        (
                                            29i32,
                                            result26_0,
                                            ::core::mem::MaybeUninit::new(i64::from(result26_1) as u64),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::HttpResponseTrailerSize(e) => {
                                        let FieldSizePayload {
                                            field_name: field_name27,
                                            field_size: field_size27,
                                        } = e;
                                        let (result29_0, result29_1, result29_2) = match field_name27 {
                                            Some(e) => {
                                                let vec28 = e;
                                                let ptr28 = vec28.as_ptr().cast::<u8>();
                                                let len28 = vec28.len();
                                                (1i32, ptr28.cast_mut(), len28)
                                            }
                                            None => (0i32, ::core::ptr::null_mut(), 0usize),
                                        };
                                        let (result30_0, result30_1) = match field_size27 {
                                            Some(e) => (1i32, _rt::as_i32(e)),
                                            None => (0i32, 0i32),
                                        };
                                        (
                                            30i32,
                                            result29_0,
                                            {
                                                let mut t = ::core::mem::MaybeUninit::<u64>::uninit();
                                                t.as_mut_ptr().cast::<*mut u8>().write(result29_1);
                                                t
                                            },
                                            result29_2 as *mut u8,
                                            result30_0 as *mut u8,
                                            result30_1 as usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::HttpResponseTransferCoding(e) => {
                                        let (result32_0, result32_1, result32_2) = match e {
                                            Some(e) => {
                                                let vec31 = e;
                                                let ptr31 = vec31.as_ptr().cast::<u8>();
                                                let len31 = vec31.len();
                                                (1i32, ptr31.cast_mut(), len31)
                                            }
                                            None => (0i32, ::core::ptr::null_mut(), 0usize),
                                        };
                                        (
                                            31i32,
                                            result32_0,
                                            {
                                                let mut t = ::core::mem::MaybeUninit::<u64>::uninit();
                                                t.as_mut_ptr().cast::<*mut u8>().write(result32_1);
                                                t
                                            },
                                            result32_2 as *mut u8,
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::HttpResponseContentCoding(e) => {
                                        let (result34_0, result34_1, result34_2) = match e {
                                            Some(e) => {
                                                let vec33 = e;
                                                let ptr33 = vec33.as_ptr().cast::<u8>();
                                                let len33 = vec33.len();
                                                (1i32, ptr33.cast_mut(), len33)
                                            }
                                            None => (0i32, ::core::ptr::null_mut(), 0usize),
                                        };
                                        (
                                            32i32,
                                            result34_0,
                                            {
                                                let mut t = ::core::mem::MaybeUninit::<u64>::uninit();
                                                t.as_mut_ptr().cast::<*mut u8>().write(result34_1);
                                                t
                                            },
                                            result34_2 as *mut u8,
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::HttpResponseTimeout => {
                                        (
                                            33i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::HttpUpgradeFailed => {
                                        (
                                            34i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::HttpProtocolError => {
                                        (
                                            35i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::LoopDetected => {
                                        (
                                            36i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::ConfigurationError => {
                                        (
                                            37i32,
                                            0i32,
                                            ::core::mem::MaybeUninit::<u64>::zeroed(),
                                            ::core::ptr::null_mut(),
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                    ErrorCode::InternalError(e) => {
                                        let (result36_0, result36_1, result36_2) = match e {
                                            Some(e) => {
                                                let vec35 = e;
                                                let ptr35 = vec35.as_ptr().cast::<u8>();
                                                let len35 = vec35.len();
                                                (1i32, ptr35.cast_mut(), len35)
                                            }
                                            None => (0i32, ::core::ptr::null_mut(), 0usize),
                                        };
                                        (
                                            38i32,
                                            result36_0,
                                            {
                                                let mut t = ::core::mem::MaybeUninit::<u64>::uninit();
                                                t.as_mut_ptr().cast::<*mut u8>().write(result36_1);
                                                t
                                            },
                                            result36_2 as *mut u8,
                                            ::core::ptr::null_mut(),
                                            0usize,
                                            0i32,
                                        )
                                    }
                                };
                                (
                                    1i32,
                                    result37_0,
                                    result37_1,
                                    result37_2,
                                    result37_3,
                                    result37_4,
                                    result37_5,
                                    result37_6,
                                )
                            }
                        };
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[static]response-outparam.set"]
                            fn wit_import(
                                _: i32,
                                _: i32,
                                _: i32,
                                _: i32,
                                _: ::core::mem::MaybeUninit<u64>,
                                _: *mut u8,
                                _: *mut u8,
                                _: usize,
                                _: i32,
                            );
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(
                            _: i32,
                            _: i32,
                            _: i32,
                            _: i32,
                            _: ::core::mem::MaybeUninit<u64>,
                            _: *mut u8,
                            _: *mut u8,
                            _: usize,
                            _: i32,
                        ) {
                            unreachable!()
                        }
                        wit_import(
                            (&param).take_handle() as i32,
                            result38_0,
                            result38_1,
                            result38_2,
                            result38_3,
                            result38_4,
                            result38_5,
                            result38_6,
                            result38_7,
                        );
                    }
                }
            }
            impl IncomingResponse {
                #[allow(unused_unsafe, clippy::all)]
                /// Returns the status code from the incoming response.
                pub fn status(&self) -> StatusCode {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]incoming-response.status"]
                            fn wit_import(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import((self).handle() as i32);
                        ret as u16
                    }
                }
            }
            impl IncomingResponse {
                #[allow(unused_unsafe, clippy::all)]
                /// Returns the headers from the incoming response.
                ///
                /// The returned `headers` resource is immutable: `set`, `append`, and
                /// `delete` operations will fail with `header-error.immutable`.
                ///
                /// This headers resource is a child: it must be dropped before the parent
                /// `incoming-response` is dropped.
                pub fn headers(&self) -> Headers {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]incoming-response.headers"]
                            fn wit_import(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import((self).handle() as i32);
                        Fields::from_handle(ret as u32)
                    }
                }
            }
            impl IncomingResponse {
                #[allow(unused_unsafe, clippy::all)]
                /// Returns the incoming body. May be called at most once. Returns error
                /// if called additional times.
                pub fn consume(&self) -> Result<IncomingBody, ()> {
                    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.2.0")]
                        extern "C" {
                            #[link_name = "[method]incoming-response.consume"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<i32>();
                                    IncomingBody::from_handle(l2 as u32)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = ();
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl IncomingBody {
                #[allow(unused_unsafe, clippy::all)]
                /// Returns the contents of the body, as a stream of bytes.
                ///
                /// Returns success on first call: the stream representing the contents
                /// can be retrieved at most once. Subsequent calls will return error.
                ///
                /// The returned `input-stream` resource is a child: it must be dropped
                /// before the parent `incoming-body` is dropped, or consumed by
                /// `incoming-body.finish`.
                ///
                /// This invariant ensures that the implementation can determine whether
                /// the user is consuming the contents of the body, waiting on the
                /// `future-trailers` to be ready, or neither. This allows for network
                /// backpressure is to be applied when the user is consuming the body,
                /// and for that backpressure to not inhibit delivery of the trailers if
                /// the user does not read the entire body.
                pub fn stream(&self) -> Result<InputStream, ()> {
                    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.2.0")]
                        extern "C" {
                            #[link_name = "[method]incoming-body.stream"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<i32>();
                                    super::super::super::wasi::io::streams::InputStream::from_handle(
                                        l2 as u32,
                                    )
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = ();
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl IncomingBody {
                #[allow(unused_unsafe, clippy::all)]
                /// Takes ownership of `incoming-body`, and returns a `future-trailers`.
                /// This function will trap if the `input-stream` child is still alive.
                pub fn finish(this: IncomingBody) -> FutureTrailers {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[static]incoming-body.finish"]
                            fn wit_import(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import((&this).take_handle() as i32);
                        FutureTrailers::from_handle(ret as u32)
                    }
                }
            }
            impl FutureTrailers {
                #[allow(unused_unsafe, clippy::all)]
                /// Returns a pollable which becomes ready when either the trailers have
                /// been received, or an error has occured. When this pollable is ready,
                /// the `get` method will return `some`.
                pub fn subscribe(&self) -> Pollable {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]future-trailers.subscribe"]
                            fn wit_import(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import((self).handle() as i32);
                        super::super::super::wasi::io::poll::Pollable::from_handle(
                            ret as u32,
                        )
                    }
                }
            }
            impl FutureTrailers {
                #[allow(unused_unsafe, clippy::all)]
                /// Returns the contents of the trailers, or an error which occured,
                /// once the future is ready.
                ///
                /// The outer `option` represents future readiness. Users can wait on this
                /// `option` to become `some` using the `subscribe` method.
                ///
                /// The outer `result` is used to retrieve the trailers or error at most
                /// once. It will be success on the first call in which the outer option
                /// is `some`, and error on subsequent calls.
                ///
                /// The inner `result` represents that either the HTTP Request or Response
                /// body, as well as any trailers, were received successfully, or that an
                /// error occured receiving them. The optional `trailers` indicates whether
                /// or not trailers were present in the body.
                ///
                /// When some `trailers` are returned by this method, the `trailers`
                /// resource is immutable, and a child. Use of the `set`, `append`, or
                /// `delete` methods will return an error, and the resource must be
                /// dropped before the parent `future-trailers` is dropped.
                pub fn get(
                    &self,
                ) -> Option<Result<Result<Option<Trailers>, ErrorCode>, ()>> {
                    unsafe {
                        #[repr(align(8))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 56]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 56],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]future-trailers.get"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(8).cast::<u8>());
                                    match l2 {
                                        0 => {
                                            let e = {
                                                let l3 = i32::from(*ptr0.add(16).cast::<u8>());
                                                match l3 {
                                                    0 => {
                                                        let e = {
                                                            let l4 = i32::from(*ptr0.add(24).cast::<u8>());
                                                            match l4 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l5 = *ptr0.add(28).cast::<i32>();
                                                                        Fields::from_handle(l5 as u32)
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            }
                                                        };
                                                        Ok(e)
                                                    }
                                                    1 => {
                                                        let e = {
                                                            let l6 = i32::from(*ptr0.add(24).cast::<u8>());
                                                            let v68 = match l6 {
                                                                0 => ErrorCode::DnsTimeout,
                                                                1 => {
                                                                    let e68 = {
                                                                        let l7 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        let l11 = i32::from(*ptr0.add(44).cast::<u8>());
                                                                        DnsErrorPayload {
                                                                            rcode: match l7 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l8 = *ptr0.add(36).cast::<*mut u8>();
                                                                                        let l9 = *ptr0.add(40).cast::<usize>();
                                                                                        let len10 = l9;
                                                                                        let bytes10 = _rt::Vec::from_raw_parts(
                                                                                            l8.cast(),
                                                                                            len10,
                                                                                            len10,
                                                                                        );
                                                                                        _rt::string_lift(bytes10)
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            },
                                                                            info_code: match l11 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l12 = i32::from(*ptr0.add(46).cast::<u16>());
                                                                                        l12 as u16
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            },
                                                                        }
                                                                    };
                                                                    ErrorCode::DnsError(e68)
                                                                }
                                                                2 => ErrorCode::DestinationNotFound,
                                                                3 => ErrorCode::DestinationUnavailable,
                                                                4 => ErrorCode::DestinationIpProhibited,
                                                                5 => ErrorCode::DestinationIpUnroutable,
                                                                6 => ErrorCode::ConnectionRefused,
                                                                7 => ErrorCode::ConnectionTerminated,
                                                                8 => ErrorCode::ConnectionTimeout,
                                                                9 => ErrorCode::ConnectionReadTimeout,
                                                                10 => ErrorCode::ConnectionWriteTimeout,
                                                                11 => ErrorCode::ConnectionLimitReached,
                                                                12 => ErrorCode::TlsProtocolError,
                                                                13 => ErrorCode::TlsCertificateError,
                                                                14 => {
                                                                    let e68 = {
                                                                        let l13 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        let l15 = i32::from(*ptr0.add(36).cast::<u8>());
                                                                        TlsAlertReceivedPayload {
                                                                            alert_id: match l13 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l14 = i32::from(*ptr0.add(33).cast::<u8>());
                                                                                        l14 as u8
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            },
                                                                            alert_message: match l15 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l16 = *ptr0.add(40).cast::<*mut u8>();
                                                                                        let l17 = *ptr0.add(44).cast::<usize>();
                                                                                        let len18 = l17;
                                                                                        let bytes18 = _rt::Vec::from_raw_parts(
                                                                                            l16.cast(),
                                                                                            len18,
                                                                                            len18,
                                                                                        );
                                                                                        _rt::string_lift(bytes18)
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            },
                                                                        }
                                                                    };
                                                                    ErrorCode::TlsAlertReceived(e68)
                                                                }
                                                                15 => ErrorCode::HttpRequestDenied,
                                                                16 => ErrorCode::HttpRequestLengthRequired,
                                                                17 => {
                                                                    let e68 = {
                                                                        let l19 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        match l19 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l20 = *ptr0.add(40).cast::<i64>();
                                                                                    l20 as u64
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpRequestBodySize(e68)
                                                                }
                                                                18 => ErrorCode::HttpRequestMethodInvalid,
                                                                19 => ErrorCode::HttpRequestUriInvalid,
                                                                20 => ErrorCode::HttpRequestUriTooLong,
                                                                21 => {
                                                                    let e68 = {
                                                                        let l21 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        match l21 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l22 = *ptr0.add(36).cast::<i32>();
                                                                                    l22 as u32
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpRequestHeaderSectionSize(e68)
                                                                }
                                                                22 => {
                                                                    let e68 = {
                                                                        let l23 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        match l23 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l24 = i32::from(*ptr0.add(36).cast::<u8>());
                                                                                    let l28 = i32::from(*ptr0.add(48).cast::<u8>());
                                                                                    FieldSizePayload {
                                                                                        field_name: match l24 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l25 = *ptr0.add(40).cast::<*mut u8>();
                                                                                                    let l26 = *ptr0.add(44).cast::<usize>();
                                                                                                    let len27 = l26;
                                                                                                    let bytes27 = _rt::Vec::from_raw_parts(
                                                                                                        l25.cast(),
                                                                                                        len27,
                                                                                                        len27,
                                                                                                    );
                                                                                                    _rt::string_lift(bytes27)
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        },
                                                                                        field_size: match l28 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l29 = *ptr0.add(52).cast::<i32>();
                                                                                                    l29 as u32
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        },
                                                                                    }
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpRequestHeaderSize(e68)
                                                                }
                                                                23 => {
                                                                    let e68 = {
                                                                        let l30 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        match l30 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l31 = *ptr0.add(36).cast::<i32>();
                                                                                    l31 as u32
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpRequestTrailerSectionSize(e68)
                                                                }
                                                                24 => {
                                                                    let e68 = {
                                                                        let l32 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        let l36 = i32::from(*ptr0.add(44).cast::<u8>());
                                                                        FieldSizePayload {
                                                                            field_name: match l32 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l33 = *ptr0.add(36).cast::<*mut u8>();
                                                                                        let l34 = *ptr0.add(40).cast::<usize>();
                                                                                        let len35 = l34;
                                                                                        let bytes35 = _rt::Vec::from_raw_parts(
                                                                                            l33.cast(),
                                                                                            len35,
                                                                                            len35,
                                                                                        );
                                                                                        _rt::string_lift(bytes35)
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            },
                                                                            field_size: match l36 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l37 = *ptr0.add(48).cast::<i32>();
                                                                                        l37 as u32
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            },
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpRequestTrailerSize(e68)
                                                                }
                                                                25 => ErrorCode::HttpResponseIncomplete,
                                                                26 => {
                                                                    let e68 = {
                                                                        let l38 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        match l38 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l39 = *ptr0.add(36).cast::<i32>();
                                                                                    l39 as u32
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpResponseHeaderSectionSize(e68)
                                                                }
                                                                27 => {
                                                                    let e68 = {
                                                                        let l40 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        let l44 = i32::from(*ptr0.add(44).cast::<u8>());
                                                                        FieldSizePayload {
                                                                            field_name: match l40 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l41 = *ptr0.add(36).cast::<*mut u8>();
                                                                                        let l42 = *ptr0.add(40).cast::<usize>();
                                                                                        let len43 = l42;
                                                                                        let bytes43 = _rt::Vec::from_raw_parts(
                                                                                            l41.cast(),
                                                                                            len43,
                                                                                            len43,
                                                                                        );
                                                                                        _rt::string_lift(bytes43)
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            },
                                                                            field_size: match l44 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l45 = *ptr0.add(48).cast::<i32>();
                                                                                        l45 as u32
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            },
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpResponseHeaderSize(e68)
                                                                }
                                                                28 => {
                                                                    let e68 = {
                                                                        let l46 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        match l46 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l47 = *ptr0.add(40).cast::<i64>();
                                                                                    l47 as u64
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpResponseBodySize(e68)
                                                                }
                                                                29 => {
                                                                    let e68 = {
                                                                        let l48 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        match l48 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l49 = *ptr0.add(36).cast::<i32>();
                                                                                    l49 as u32
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpResponseTrailerSectionSize(e68)
                                                                }
                                                                30 => {
                                                                    let e68 = {
                                                                        let l50 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        let l54 = i32::from(*ptr0.add(44).cast::<u8>());
                                                                        FieldSizePayload {
                                                                            field_name: match l50 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l51 = *ptr0.add(36).cast::<*mut u8>();
                                                                                        let l52 = *ptr0.add(40).cast::<usize>();
                                                                                        let len53 = l52;
                                                                                        let bytes53 = _rt::Vec::from_raw_parts(
                                                                                            l51.cast(),
                                                                                            len53,
                                                                                            len53,
                                                                                        );
                                                                                        _rt::string_lift(bytes53)
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            },
                                                                            field_size: match l54 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l55 = *ptr0.add(48).cast::<i32>();
                                                                                        l55 as u32
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            },
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpResponseTrailerSize(e68)
                                                                }
                                                                31 => {
                                                                    let e68 = {
                                                                        let l56 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        match l56 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l57 = *ptr0.add(36).cast::<*mut u8>();
                                                                                    let l58 = *ptr0.add(40).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(),
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpResponseTransferCoding(e68)
                                                                }
                                                                32 => {
                                                                    let e68 = {
                                                                        let l60 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        match l60 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l61 = *ptr0.add(36).cast::<*mut u8>();
                                                                                    let l62 = *ptr0.add(40).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(),
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpResponseContentCoding(e68)
                                                                }
                                                                33 => ErrorCode::HttpResponseTimeout,
                                                                34 => ErrorCode::HttpUpgradeFailed,
                                                                35 => ErrorCode::HttpProtocolError,
                                                                36 => ErrorCode::LoopDetected,
                                                                37 => ErrorCode::ConfigurationError,
                                                                n => {
                                                                    debug_assert_eq!(n, 38, "invalid enum discriminant");
                                                                    let e68 = {
                                                                        let l64 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        match l64 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l65 = *ptr0.add(36).cast::<*mut u8>();
                                                                                    let l66 = *ptr0.add(40).cast::<usize>();
                                                                                    let len67 = l66;
                                                                                    let bytes67 = _rt::Vec::from_raw_parts(
                                                                                        l65.cast(),
                                                                                        len67,
                                                                                        len67,
                                                                                    );
                                                                                    _rt::string_lift(bytes67)
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        }
                                                                    };
                                                                    ErrorCode::InternalError(e68)
                                                                }
                                                            };
                                                            v68
                                                        };
                                                        Err(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                }
                                            };
                                            Ok(e)
                                        }
                                        1 => {
                                            let e = ();
                                            Err(e)
                                        }
                                        _ => _rt::invalid_enum_discriminant(),
                                    }
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl OutgoingResponse {
                #[allow(unused_unsafe, clippy::all)]
                /// Construct an `outgoing-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.
                pub fn new(headers: Headers) -> Self {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[constructor]outgoing-response"]
                            fn wit_import(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import((&headers).take_handle() as i32);
                        OutgoingResponse::from_handle(ret as u32)
                    }
                }
            }
            impl OutgoingResponse {
                #[allow(unused_unsafe, clippy::all)]
                /// Get the HTTP Status Code for the Response.
                pub fn status_code(&self) -> StatusCode {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]outgoing-response.status-code"]
                            fn wit_import(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import((self).handle() as i32);
                        ret as u16
                    }
                }
            }
            impl OutgoingResponse {
                #[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.
                pub fn set_status_code(
                    &self,
                    status_code: StatusCode,
                ) -> Result<(), ()> {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]outgoing-response.set-status-code"]
                            fn wit_import(_: i32, _: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import(
                            (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 OutgoingResponse {
                #[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`.
                ///
                /// This headers resource is a child: it must be dropped before the parent
                /// `outgoing-request` is dropped, or its ownership is transfered to
                /// another component by e.g. `outgoing-handler.handle`.
                pub fn headers(&self) -> Headers {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]outgoing-response.headers"]
                            fn wit_import(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import((self).handle() as i32);
                        Fields::from_handle(ret as u32)
                    }
                }
            }
            impl OutgoingResponse {
                #[allow(unused_unsafe, clippy::all)]
                /// Returns the resource corresponding to the outgoing Body for this Response.
                ///
                /// Returns success on the first call: the `outgoing-body` resource for
                /// this `outgoing-response` can be retrieved at most once. Subsequent
                /// calls will return error.
                pub fn body(&self) -> Result<OutgoingBody, ()> {
                    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.2.0")]
                        extern "C" {
                            #[link_name = "[method]outgoing-response.body"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<i32>();
                                    OutgoingBody::from_handle(l2 as u32)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = ();
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl OutgoingBody {
                #[allow(unused_unsafe, clippy::all)]
                /// Returns a stream for writing the body contents.
                ///
                /// The returned `output-stream` is a child resource: it must be dropped
                /// before the parent `outgoing-body` resource is dropped (or finished),
                /// otherwise the `outgoing-body` drop or `finish` will trap.
                ///
                /// Returns success on the first call: the `output-stream` resource for
                /// this `outgoing-body` may be retrieved at most once. Subsequent calls
                /// will return error.
                pub fn write(&self) -> Result<OutputStream, ()> {
                    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.2.0")]
                        extern "C" {
                            #[link_name = "[method]outgoing-body.write"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<i32>();
                                    super::super::super::wasi::io::streams::OutputStream::from_handle(
                                        l2 as u32,
                                    )
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = ();
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl OutgoingBody {
                #[allow(unused_unsafe, clippy::all)]
                /// Finalize an outgoing body, optionally providing trailers. This must be
                /// called to signal that the response is complete. If the `outgoing-body`
                /// is dropped without calling `outgoing-body.finalize`, the implementation
                /// should treat the body as corrupted.
                ///
                /// Fails if the body's `outgoing-request` or `outgoing-response` was
                /// constructed with a Content-Length header, and the contents written
                /// to the body (via `write`) does not match the value given in the
                /// Content-Length.
                pub fn finish(
                    this: OutgoingBody,
                    trailers: Option<Trailers>,
                ) -> Result<(), ErrorCode> {
                    unsafe {
                        #[repr(align(8))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 40]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 40],
                        );
                        let (result0_0, result0_1) = match &trailers {
                            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.2.0")]
                        extern "C" {
                            #[link_name = "[static]outgoing-body.finish"]
                            fn wit_import(_: i32, _: i32, _: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i32, _: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import(
                            (&this).take_handle() as i32,
                            result0_0,
                            result0_1,
                            ptr1,
                        );
                        let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                        match l2 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = i32::from(*ptr1.add(8).cast::<u8>());
                                    let v65 = match l3 {
                                        0 => ErrorCode::DnsTimeout,
                                        1 => {
                                            let e65 = {
                                                let l4 = i32::from(*ptr1.add(16).cast::<u8>());
                                                let l8 = i32::from(*ptr1.add(28).cast::<u8>());
                                                DnsErrorPayload {
                                                    rcode: match l4 {
                                                        0 => None,
                                                        1 => {
                                                            let e = {
                                                                let l5 = *ptr1.add(20).cast::<*mut u8>();
                                                                let l6 = *ptr1.add(24).cast::<usize>();
                                                                let len7 = l6;
                                                                let bytes7 = _rt::Vec::from_raw_parts(
                                                                    l5.cast(),
                                                                    len7,
                                                                    len7,
                                                                );
                                                                _rt::string_lift(bytes7)
                                                            };
                                                            Some(e)
                                                        }
                                                        _ => _rt::invalid_enum_discriminant(),
                                                    },
                                                    info_code: match l8 {
                                                        0 => None,
                                                        1 => {
                                                            let e = {
                                                                let l9 = i32::from(*ptr1.add(30).cast::<u16>());
                                                                l9 as u16
                                                            };
                                                            Some(e)
                                                        }
                                                        _ => _rt::invalid_enum_discriminant(),
                                                    },
                                                }
                                            };
                                            ErrorCode::DnsError(e65)
                                        }
                                        2 => ErrorCode::DestinationNotFound,
                                        3 => ErrorCode::DestinationUnavailable,
                                        4 => ErrorCode::DestinationIpProhibited,
                                        5 => ErrorCode::DestinationIpUnroutable,
                                        6 => ErrorCode::ConnectionRefused,
                                        7 => ErrorCode::ConnectionTerminated,
                                        8 => ErrorCode::ConnectionTimeout,
                                        9 => ErrorCode::ConnectionReadTimeout,
                                        10 => ErrorCode::ConnectionWriteTimeout,
                                        11 => ErrorCode::ConnectionLimitReached,
                                        12 => ErrorCode::TlsProtocolError,
                                        13 => ErrorCode::TlsCertificateError,
                                        14 => {
                                            let e65 = {
                                                let l10 = i32::from(*ptr1.add(16).cast::<u8>());
                                                let l12 = i32::from(*ptr1.add(20).cast::<u8>());
                                                TlsAlertReceivedPayload {
                                                    alert_id: match l10 {
                                                        0 => None,
                                                        1 => {
                                                            let e = {
                                                                let l11 = i32::from(*ptr1.add(17).cast::<u8>());
                                                                l11 as u8
                                                            };
                                                            Some(e)
                                                        }
                                                        _ => _rt::invalid_enum_discriminant(),
                                                    },
                                                    alert_message: match l12 {
                                                        0 => None,
                                                        1 => {
                                                            let e = {
                                                                let l13 = *ptr1.add(24).cast::<*mut u8>();
                                                                let l14 = *ptr1.add(28).cast::<usize>();
                                                                let len15 = l14;
                                                                let bytes15 = _rt::Vec::from_raw_parts(
                                                                    l13.cast(),
                                                                    len15,
                                                                    len15,
                                                                );
                                                                _rt::string_lift(bytes15)
                                                            };
                                                            Some(e)
                                                        }
                                                        _ => _rt::invalid_enum_discriminant(),
                                                    },
                                                }
                                            };
                                            ErrorCode::TlsAlertReceived(e65)
                                        }
                                        15 => ErrorCode::HttpRequestDenied,
                                        16 => ErrorCode::HttpRequestLengthRequired,
                                        17 => {
                                            let e65 = {
                                                let l16 = i32::from(*ptr1.add(16).cast::<u8>());
                                                match l16 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l17 = *ptr1.add(24).cast::<i64>();
                                                            l17 as u64
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                }
                                            };
                                            ErrorCode::HttpRequestBodySize(e65)
                                        }
                                        18 => ErrorCode::HttpRequestMethodInvalid,
                                        19 => ErrorCode::HttpRequestUriInvalid,
                                        20 => ErrorCode::HttpRequestUriTooLong,
                                        21 => {
                                            let e65 = {
                                                let l18 = i32::from(*ptr1.add(16).cast::<u8>());
                                                match l18 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l19 = *ptr1.add(20).cast::<i32>();
                                                            l19 as u32
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                }
                                            };
                                            ErrorCode::HttpRequestHeaderSectionSize(e65)
                                        }
                                        22 => {
                                            let e65 = {
                                                let l20 = i32::from(*ptr1.add(16).cast::<u8>());
                                                match l20 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l21 = i32::from(*ptr1.add(20).cast::<u8>());
                                                            let l25 = i32::from(*ptr1.add(32).cast::<u8>());
                                                            FieldSizePayload {
                                                                field_name: match l21 {
                                                                    0 => None,
                                                                    1 => {
                                                                        let e = {
                                                                            let l22 = *ptr1.add(24).cast::<*mut u8>();
                                                                            let l23 = *ptr1.add(28).cast::<usize>();
                                                                            let len24 = l23;
                                                                            let bytes24 = _rt::Vec::from_raw_parts(
                                                                                l22.cast(),
                                                                                len24,
                                                                                len24,
                                                                            );
                                                                            _rt::string_lift(bytes24)
                                                                        };
                                                                        Some(e)
                                                                    }
                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                },
                                                                field_size: match l25 {
                                                                    0 => None,
                                                                    1 => {
                                                                        let e = {
                                                                            let l26 = *ptr1.add(36).cast::<i32>();
                                                                            l26 as u32
                                                                        };
                                                                        Some(e)
                                                                    }
                                                                    _ => _rt::invalid_enum_discriminant(),
                                                                },
                                                            }
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                }
                                            };
                                            ErrorCode::HttpRequestHeaderSize(e65)
                                        }
                                        23 => {
                                            let e65 = {
                                                let l27 = i32::from(*ptr1.add(16).cast::<u8>());
                                                match l27 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l28 = *ptr1.add(20).cast::<i32>();
                                                            l28 as u32
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                }
                                            };
                                            ErrorCode::HttpRequestTrailerSectionSize(e65)
                                        }
                                        24 => {
                                            let e65 = {
                                                let l29 = i32::from(*ptr1.add(16).cast::<u8>());
                                                let l33 = i32::from(*ptr1.add(28).cast::<u8>());
                                                FieldSizePayload {
                                                    field_name: match l29 {
                                                        0 => None,
                                                        1 => {
                                                            let e = {
                                                                let l30 = *ptr1.add(20).cast::<*mut u8>();
                                                                let l31 = *ptr1.add(24).cast::<usize>();
                                                                let len32 = l31;
                                                                let bytes32 = _rt::Vec::from_raw_parts(
                                                                    l30.cast(),
                                                                    len32,
                                                                    len32,
                                                                );
                                                                _rt::string_lift(bytes32)
                                                            };
                                                            Some(e)
                                                        }
                                                        _ => _rt::invalid_enum_discriminant(),
                                                    },
                                                    field_size: match l33 {
                                                        0 => None,
                                                        1 => {
                                                            let e = {
                                                                let l34 = *ptr1.add(32).cast::<i32>();
                                                                l34 as u32
                                                            };
                                                            Some(e)
                                                        }
                                                        _ => _rt::invalid_enum_discriminant(),
                                                    },
                                                }
                                            };
                                            ErrorCode::HttpRequestTrailerSize(e65)
                                        }
                                        25 => ErrorCode::HttpResponseIncomplete,
                                        26 => {
                                            let e65 = {
                                                let l35 = i32::from(*ptr1.add(16).cast::<u8>());
                                                match l35 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l36 = *ptr1.add(20).cast::<i32>();
                                                            l36 as u32
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                }
                                            };
                                            ErrorCode::HttpResponseHeaderSectionSize(e65)
                                        }
                                        27 => {
                                            let e65 = {
                                                let l37 = i32::from(*ptr1.add(16).cast::<u8>());
                                                let l41 = i32::from(*ptr1.add(28).cast::<u8>());
                                                FieldSizePayload {
                                                    field_name: match l37 {
                                                        0 => None,
                                                        1 => {
                                                            let e = {
                                                                let l38 = *ptr1.add(20).cast::<*mut u8>();
                                                                let l39 = *ptr1.add(24).cast::<usize>();
                                                                let len40 = l39;
                                                                let bytes40 = _rt::Vec::from_raw_parts(
                                                                    l38.cast(),
                                                                    len40,
                                                                    len40,
                                                                );
                                                                _rt::string_lift(bytes40)
                                                            };
                                                            Some(e)
                                                        }
                                                        _ => _rt::invalid_enum_discriminant(),
                                                    },
                                                    field_size: match l41 {
                                                        0 => None,
                                                        1 => {
                                                            let e = {
                                                                let l42 = *ptr1.add(32).cast::<i32>();
                                                                l42 as u32
                                                            };
                                                            Some(e)
                                                        }
                                                        _ => _rt::invalid_enum_discriminant(),
                                                    },
                                                }
                                            };
                                            ErrorCode::HttpResponseHeaderSize(e65)
                                        }
                                        28 => {
                                            let e65 = {
                                                let l43 = i32::from(*ptr1.add(16).cast::<u8>());
                                                match l43 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l44 = *ptr1.add(24).cast::<i64>();
                                                            l44 as u64
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                }
                                            };
                                            ErrorCode::HttpResponseBodySize(e65)
                                        }
                                        29 => {
                                            let e65 = {
                                                let l45 = i32::from(*ptr1.add(16).cast::<u8>());
                                                match l45 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l46 = *ptr1.add(20).cast::<i32>();
                                                            l46 as u32
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                }
                                            };
                                            ErrorCode::HttpResponseTrailerSectionSize(e65)
                                        }
                                        30 => {
                                            let e65 = {
                                                let l47 = i32::from(*ptr1.add(16).cast::<u8>());
                                                let l51 = i32::from(*ptr1.add(28).cast::<u8>());
                                                FieldSizePayload {
                                                    field_name: match l47 {
                                                        0 => None,
                                                        1 => {
                                                            let e = {
                                                                let l48 = *ptr1.add(20).cast::<*mut u8>();
                                                                let l49 = *ptr1.add(24).cast::<usize>();
                                                                let len50 = l49;
                                                                let bytes50 = _rt::Vec::from_raw_parts(
                                                                    l48.cast(),
                                                                    len50,
                                                                    len50,
                                                                );
                                                                _rt::string_lift(bytes50)
                                                            };
                                                            Some(e)
                                                        }
                                                        _ => _rt::invalid_enum_discriminant(),
                                                    },
                                                    field_size: match l51 {
                                                        0 => None,
                                                        1 => {
                                                            let e = {
                                                                let l52 = *ptr1.add(32).cast::<i32>();
                                                                l52 as u32
                                                            };
                                                            Some(e)
                                                        }
                                                        _ => _rt::invalid_enum_discriminant(),
                                                    },
                                                }
                                            };
                                            ErrorCode::HttpResponseTrailerSize(e65)
                                        }
                                        31 => {
                                            let e65 = {
                                                let l53 = i32::from(*ptr1.add(16).cast::<u8>());
                                                match l53 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l54 = *ptr1.add(20).cast::<*mut u8>();
                                                            let l55 = *ptr1.add(24).cast::<usize>();
                                                            let len56 = l55;
                                                            let bytes56 = _rt::Vec::from_raw_parts(
                                                                l54.cast(),
                                                                len56,
                                                                len56,
                                                            );
                                                            _rt::string_lift(bytes56)
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                }
                                            };
                                            ErrorCode::HttpResponseTransferCoding(e65)
                                        }
                                        32 => {
                                            let e65 = {
                                                let l57 = i32::from(*ptr1.add(16).cast::<u8>());
                                                match l57 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l58 = *ptr1.add(20).cast::<*mut u8>();
                                                            let l59 = *ptr1.add(24).cast::<usize>();
                                                            let len60 = l59;
                                                            let bytes60 = _rt::Vec::from_raw_parts(
                                                                l58.cast(),
                                                                len60,
                                                                len60,
                                                            );
                                                            _rt::string_lift(bytes60)
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                }
                                            };
                                            ErrorCode::HttpResponseContentCoding(e65)
                                        }
                                        33 => ErrorCode::HttpResponseTimeout,
                                        34 => ErrorCode::HttpUpgradeFailed,
                                        35 => ErrorCode::HttpProtocolError,
                                        36 => ErrorCode::LoopDetected,
                                        37 => ErrorCode::ConfigurationError,
                                        n => {
                                            debug_assert_eq!(n, 38, "invalid enum discriminant");
                                            let e65 = {
                                                let l61 = i32::from(*ptr1.add(16).cast::<u8>());
                                                match l61 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l62 = *ptr1.add(20).cast::<*mut u8>();
                                                            let l63 = *ptr1.add(24).cast::<usize>();
                                                            let len64 = l63;
                                                            let bytes64 = _rt::Vec::from_raw_parts(
                                                                l62.cast(),
                                                                len64,
                                                                len64,
                                                            );
                                                            _rt::string_lift(bytes64)
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                }
                                            };
                                            ErrorCode::InternalError(e65)
                                        }
                                    };
                                    v65
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl FutureIncomingResponse {
                #[allow(unused_unsafe, clippy::all)]
                /// Returns a pollable which becomes ready when either the Response has
                /// been received, or an error has occured. When this pollable is ready,
                /// the `get` method will return `some`.
                pub fn subscribe(&self) -> Pollable {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]future-incoming-response.subscribe"]
                            fn wit_import(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import((self).handle() as i32);
                        super::super::super::wasi::io::poll::Pollable::from_handle(
                            ret as u32,
                        )
                    }
                }
            }
            impl FutureIncomingResponse {
                #[allow(unused_unsafe, clippy::all)]
                /// Returns the incoming HTTP Response, or an error, once one is ready.
                ///
                /// The outer `option` represents future readiness. Users can wait on this
                /// `option` to become `some` using the `subscribe` method.
                ///
                /// The outer `result` is used to retrieve the response or error at most
                /// once. It will be success on the first call in which the outer option
                /// is `some`, and error on subsequent calls.
                ///
                /// The inner `result` represents that either the incoming HTTP Response
                /// status and headers have recieved successfully, or that an error
                /// occured. Errors may also occur while consuming the response body,
                /// but those will be reported by the `incoming-body` and its
                /// `output-stream` child.
                pub fn get(
                    &self,
                ) -> Option<Result<Result<IncomingResponse, ErrorCode>, ()>> {
                    unsafe {
                        #[repr(align(8))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 56]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 56],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:http/types@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]future-incoming-response.get"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => None,
                            1 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(8).cast::<u8>());
                                    match l2 {
                                        0 => {
                                            let e = {
                                                let l3 = i32::from(*ptr0.add(16).cast::<u8>());
                                                match l3 {
                                                    0 => {
                                                        let e = {
                                                            let l4 = *ptr0.add(24).cast::<i32>();
                                                            IncomingResponse::from_handle(l4 as u32)
                                                        };
                                                        Ok(e)
                                                    }
                                                    1 => {
                                                        let e = {
                                                            let l5 = i32::from(*ptr0.add(24).cast::<u8>());
                                                            let v67 = match l5 {
                                                                0 => ErrorCode::DnsTimeout,
                                                                1 => {
                                                                    let e67 = {
                                                                        let l6 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        let l10 = i32::from(*ptr0.add(44).cast::<u8>());
                                                                        DnsErrorPayload {
                                                                            rcode: match l6 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l7 = *ptr0.add(36).cast::<*mut u8>();
                                                                                        let l8 = *ptr0.add(40).cast::<usize>();
                                                                                        let len9 = l8;
                                                                                        let bytes9 = _rt::Vec::from_raw_parts(
                                                                                            l7.cast(),
                                                                                            len9,
                                                                                            len9,
                                                                                        );
                                                                                        _rt::string_lift(bytes9)
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            },
                                                                            info_code: match l10 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l11 = i32::from(*ptr0.add(46).cast::<u16>());
                                                                                        l11 as u16
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            },
                                                                        }
                                                                    };
                                                                    ErrorCode::DnsError(e67)
                                                                }
                                                                2 => ErrorCode::DestinationNotFound,
                                                                3 => ErrorCode::DestinationUnavailable,
                                                                4 => ErrorCode::DestinationIpProhibited,
                                                                5 => ErrorCode::DestinationIpUnroutable,
                                                                6 => ErrorCode::ConnectionRefused,
                                                                7 => ErrorCode::ConnectionTerminated,
                                                                8 => ErrorCode::ConnectionTimeout,
                                                                9 => ErrorCode::ConnectionReadTimeout,
                                                                10 => ErrorCode::ConnectionWriteTimeout,
                                                                11 => ErrorCode::ConnectionLimitReached,
                                                                12 => ErrorCode::TlsProtocolError,
                                                                13 => ErrorCode::TlsCertificateError,
                                                                14 => {
                                                                    let e67 = {
                                                                        let l12 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        let l14 = i32::from(*ptr0.add(36).cast::<u8>());
                                                                        TlsAlertReceivedPayload {
                                                                            alert_id: match l12 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l13 = i32::from(*ptr0.add(33).cast::<u8>());
                                                                                        l13 as u8
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            },
                                                                            alert_message: match l14 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l15 = *ptr0.add(40).cast::<*mut u8>();
                                                                                        let l16 = *ptr0.add(44).cast::<usize>();
                                                                                        let len17 = l16;
                                                                                        let bytes17 = _rt::Vec::from_raw_parts(
                                                                                            l15.cast(),
                                                                                            len17,
                                                                                            len17,
                                                                                        );
                                                                                        _rt::string_lift(bytes17)
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            },
                                                                        }
                                                                    };
                                                                    ErrorCode::TlsAlertReceived(e67)
                                                                }
                                                                15 => ErrorCode::HttpRequestDenied,
                                                                16 => ErrorCode::HttpRequestLengthRequired,
                                                                17 => {
                                                                    let e67 = {
                                                                        let l18 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        match l18 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l19 = *ptr0.add(40).cast::<i64>();
                                                                                    l19 as u64
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpRequestBodySize(e67)
                                                                }
                                                                18 => ErrorCode::HttpRequestMethodInvalid,
                                                                19 => ErrorCode::HttpRequestUriInvalid,
                                                                20 => ErrorCode::HttpRequestUriTooLong,
                                                                21 => {
                                                                    let e67 = {
                                                                        let l20 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        match l20 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l21 = *ptr0.add(36).cast::<i32>();
                                                                                    l21 as u32
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpRequestHeaderSectionSize(e67)
                                                                }
                                                                22 => {
                                                                    let e67 = {
                                                                        let l22 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        match l22 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l23 = i32::from(*ptr0.add(36).cast::<u8>());
                                                                                    let l27 = i32::from(*ptr0.add(48).cast::<u8>());
                                                                                    FieldSizePayload {
                                                                                        field_name: match l23 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l24 = *ptr0.add(40).cast::<*mut u8>();
                                                                                                    let l25 = *ptr0.add(44).cast::<usize>();
                                                                                                    let len26 = l25;
                                                                                                    let bytes26 = _rt::Vec::from_raw_parts(
                                                                                                        l24.cast(),
                                                                                                        len26,
                                                                                                        len26,
                                                                                                    );
                                                                                                    _rt::string_lift(bytes26)
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        },
                                                                                        field_size: match l27 {
                                                                                            0 => None,
                                                                                            1 => {
                                                                                                let e = {
                                                                                                    let l28 = *ptr0.add(52).cast::<i32>();
                                                                                                    l28 as u32
                                                                                                };
                                                                                                Some(e)
                                                                                            }
                                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                                        },
                                                                                    }
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpRequestHeaderSize(e67)
                                                                }
                                                                23 => {
                                                                    let e67 = {
                                                                        let l29 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        match l29 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l30 = *ptr0.add(36).cast::<i32>();
                                                                                    l30 as u32
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpRequestTrailerSectionSize(e67)
                                                                }
                                                                24 => {
                                                                    let e67 = {
                                                                        let l31 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        let l35 = i32::from(*ptr0.add(44).cast::<u8>());
                                                                        FieldSizePayload {
                                                                            field_name: match l31 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l32 = *ptr0.add(36).cast::<*mut u8>();
                                                                                        let l33 = *ptr0.add(40).cast::<usize>();
                                                                                        let len34 = l33;
                                                                                        let bytes34 = _rt::Vec::from_raw_parts(
                                                                                            l32.cast(),
                                                                                            len34,
                                                                                            len34,
                                                                                        );
                                                                                        _rt::string_lift(bytes34)
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            },
                                                                            field_size: match l35 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l36 = *ptr0.add(48).cast::<i32>();
                                                                                        l36 as u32
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            },
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpRequestTrailerSize(e67)
                                                                }
                                                                25 => ErrorCode::HttpResponseIncomplete,
                                                                26 => {
                                                                    let e67 = {
                                                                        let l37 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        match l37 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l38 = *ptr0.add(36).cast::<i32>();
                                                                                    l38 as u32
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpResponseHeaderSectionSize(e67)
                                                                }
                                                                27 => {
                                                                    let e67 = {
                                                                        let l39 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        let l43 = i32::from(*ptr0.add(44).cast::<u8>());
                                                                        FieldSizePayload {
                                                                            field_name: match l39 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l40 = *ptr0.add(36).cast::<*mut u8>();
                                                                                        let l41 = *ptr0.add(40).cast::<usize>();
                                                                                        let len42 = l41;
                                                                                        let bytes42 = _rt::Vec::from_raw_parts(
                                                                                            l40.cast(),
                                                                                            len42,
                                                                                            len42,
                                                                                        );
                                                                                        _rt::string_lift(bytes42)
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            },
                                                                            field_size: match l43 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l44 = *ptr0.add(48).cast::<i32>();
                                                                                        l44 as u32
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            },
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpResponseHeaderSize(e67)
                                                                }
                                                                28 => {
                                                                    let e67 = {
                                                                        let l45 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        match l45 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l46 = *ptr0.add(40).cast::<i64>();
                                                                                    l46 as u64
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpResponseBodySize(e67)
                                                                }
                                                                29 => {
                                                                    let e67 = {
                                                                        let l47 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        match l47 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l48 = *ptr0.add(36).cast::<i32>();
                                                                                    l48 as u32
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpResponseTrailerSectionSize(e67)
                                                                }
                                                                30 => {
                                                                    let e67 = {
                                                                        let l49 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        let l53 = i32::from(*ptr0.add(44).cast::<u8>());
                                                                        FieldSizePayload {
                                                                            field_name: match l49 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l50 = *ptr0.add(36).cast::<*mut u8>();
                                                                                        let l51 = *ptr0.add(40).cast::<usize>();
                                                                                        let len52 = l51;
                                                                                        let bytes52 = _rt::Vec::from_raw_parts(
                                                                                            l50.cast(),
                                                                                            len52,
                                                                                            len52,
                                                                                        );
                                                                                        _rt::string_lift(bytes52)
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            },
                                                                            field_size: match l53 {
                                                                                0 => None,
                                                                                1 => {
                                                                                    let e = {
                                                                                        let l54 = *ptr0.add(48).cast::<i32>();
                                                                                        l54 as u32
                                                                                    };
                                                                                    Some(e)
                                                                                }
                                                                                _ => _rt::invalid_enum_discriminant(),
                                                                            },
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpResponseTrailerSize(e67)
                                                                }
                                                                31 => {
                                                                    let e67 = {
                                                                        let l55 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        match l55 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l56 = *ptr0.add(36).cast::<*mut u8>();
                                                                                    let l57 = *ptr0.add(40).cast::<usize>();
                                                                                    let len58 = l57;
                                                                                    let bytes58 = _rt::Vec::from_raw_parts(
                                                                                        l56.cast(),
                                                                                        len58,
                                                                                        len58,
                                                                                    );
                                                                                    _rt::string_lift(bytes58)
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpResponseTransferCoding(e67)
                                                                }
                                                                32 => {
                                                                    let e67 = {
                                                                        let l59 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        match l59 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l60 = *ptr0.add(36).cast::<*mut u8>();
                                                                                    let l61 = *ptr0.add(40).cast::<usize>();
                                                                                    let len62 = l61;
                                                                                    let bytes62 = _rt::Vec::from_raw_parts(
                                                                                        l60.cast(),
                                                                                        len62,
                                                                                        len62,
                                                                                    );
                                                                                    _rt::string_lift(bytes62)
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        }
                                                                    };
                                                                    ErrorCode::HttpResponseContentCoding(e67)
                                                                }
                                                                33 => ErrorCode::HttpResponseTimeout,
                                                                34 => ErrorCode::HttpUpgradeFailed,
                                                                35 => ErrorCode::HttpProtocolError,
                                                                36 => ErrorCode::LoopDetected,
                                                                37 => ErrorCode::ConfigurationError,
                                                                n => {
                                                                    debug_assert_eq!(n, 38, "invalid enum discriminant");
                                                                    let e67 = {
                                                                        let l63 = i32::from(*ptr0.add(32).cast::<u8>());
                                                                        match l63 {
                                                                            0 => None,
                                                                            1 => {
                                                                                let e = {
                                                                                    let l64 = *ptr0.add(36).cast::<*mut u8>();
                                                                                    let l65 = *ptr0.add(40).cast::<usize>();
                                                                                    let len66 = l65;
                                                                                    let bytes66 = _rt::Vec::from_raw_parts(
                                                                                        l64.cast(),
                                                                                        len66,
                                                                                        len66,
                                                                                    );
                                                                                    _rt::string_lift(bytes66)
                                                                                };
                                                                                Some(e)
                                                                            }
                                                                            _ => _rt::invalid_enum_discriminant(),
                                                                        }
                                                                    };
                                                                    ErrorCode::InternalError(e67)
                                                                }
                                                            };
                                                            v67
                                                        };
                                                        Err(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                }
                                            };
                                            Ok(e)
                                        }
                                        1 => {
                                            let e = ();
                                            Err(e)
                                        }
                                        _ => _rt::invalid_enum_discriminant(),
                                    }
                                };
                                Some(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
        }
        /// This interface defines a handler of outgoing HTTP Requests. It should be
        /// imported by components which wish to make HTTP Requests.
        #[allow(dead_code, clippy::all)]
        pub mod outgoing_handler {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            use super::super::super::_rt;
            pub type OutgoingRequest = super::super::super::wasi::http::types::OutgoingRequest;
            pub type RequestOptions = super::super::super::wasi::http::types::RequestOptions;
            pub type FutureIncomingResponse = super::super::super::wasi::http::types::FutureIncomingResponse;
            pub type ErrorCode = super::super::super::wasi::http::types::ErrorCode;
            #[allow(unused_unsafe, clippy::all)]
            /// This function is invoked with an outgoing HTTP Request, and it returns
            /// a resource `future-incoming-response` which represents an HTTP Response
            /// which may arrive in the future.
            ///
            /// The `options` argument accepts optional parameters for the HTTP
            /// protocol's transport layer.
            ///
            /// This function may return an error if the `outgoing-request` is invalid
            /// or not allowed to be made. Otherwise, protocol errors are reported
            /// through the `future-incoming-response`.
            pub fn handle(
                request: OutgoingRequest,
                options: Option<RequestOptions>,
            ) -> Result<FutureIncomingResponse, ErrorCode> {
                unsafe {
                    #[repr(align(8))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 40]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 40]);
                    let (result0_0, result0_1) = match &options {
                        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/outgoing-handler@0.2.0")]
                    extern "C" {
                        #[link_name = "handle"]
                        fn wit_import(_: i32, _: i32, _: i32, _: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i32, _: i32, _: i32, _: *mut u8) {
                        unreachable!()
                    }
                    wit_import(
                        (&request).take_handle() as i32,
                        result0_0,
                        result0_1,
                        ptr1,
                    );
                    let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                    match l2 {
                        0 => {
                            let e = {
                                let l3 = *ptr1.add(8).cast::<i32>();
                                super::super::super::wasi::http::types::FutureIncomingResponse::from_handle(
                                    l3 as u32,
                                )
                            };
                            Ok(e)
                        }
                        1 => {
                            let e = {
                                let l4 = i32::from(*ptr1.add(8).cast::<u8>());
                                use super::super::super::wasi::http::types::ErrorCode as V66;
                                let v66 = match l4 {
                                    0 => V66::DnsTimeout,
                                    1 => {
                                        let e66 = {
                                            let l5 = i32::from(*ptr1.add(16).cast::<u8>());
                                            let l9 = i32::from(*ptr1.add(28).cast::<u8>());
                                            super::super::super::wasi::http::types::DnsErrorPayload {
                                                rcode: match l5 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l6 = *ptr1.add(20).cast::<*mut u8>();
                                                            let l7 = *ptr1.add(24).cast::<usize>();
                                                            let len8 = l7;
                                                            let bytes8 = _rt::Vec::from_raw_parts(
                                                                l6.cast(),
                                                                len8,
                                                                len8,
                                                            );
                                                            _rt::string_lift(bytes8)
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                },
                                                info_code: match l9 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l10 = i32::from(*ptr1.add(30).cast::<u16>());
                                                            l10 as u16
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                },
                                            }
                                        };
                                        V66::DnsError(e66)
                                    }
                                    2 => V66::DestinationNotFound,
                                    3 => V66::DestinationUnavailable,
                                    4 => V66::DestinationIpProhibited,
                                    5 => V66::DestinationIpUnroutable,
                                    6 => V66::ConnectionRefused,
                                    7 => V66::ConnectionTerminated,
                                    8 => V66::ConnectionTimeout,
                                    9 => V66::ConnectionReadTimeout,
                                    10 => V66::ConnectionWriteTimeout,
                                    11 => V66::ConnectionLimitReached,
                                    12 => V66::TlsProtocolError,
                                    13 => V66::TlsCertificateError,
                                    14 => {
                                        let e66 = {
                                            let l11 = i32::from(*ptr1.add(16).cast::<u8>());
                                            let l13 = i32::from(*ptr1.add(20).cast::<u8>());
                                            super::super::super::wasi::http::types::TlsAlertReceivedPayload {
                                                alert_id: match l11 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l12 = i32::from(*ptr1.add(17).cast::<u8>());
                                                            l12 as u8
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                },
                                                alert_message: match l13 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l14 = *ptr1.add(24).cast::<*mut u8>();
                                                            let l15 = *ptr1.add(28).cast::<usize>();
                                                            let len16 = l15;
                                                            let bytes16 = _rt::Vec::from_raw_parts(
                                                                l14.cast(),
                                                                len16,
                                                                len16,
                                                            );
                                                            _rt::string_lift(bytes16)
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                },
                                            }
                                        };
                                        V66::TlsAlertReceived(e66)
                                    }
                                    15 => V66::HttpRequestDenied,
                                    16 => V66::HttpRequestLengthRequired,
                                    17 => {
                                        let e66 = {
                                            let l17 = i32::from(*ptr1.add(16).cast::<u8>());
                                            match l17 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l18 = *ptr1.add(24).cast::<i64>();
                                                        l18 as u64
                                                    };
                                                    Some(e)
                                                }
                                                _ => _rt::invalid_enum_discriminant(),
                                            }
                                        };
                                        V66::HttpRequestBodySize(e66)
                                    }
                                    18 => V66::HttpRequestMethodInvalid,
                                    19 => V66::HttpRequestUriInvalid,
                                    20 => V66::HttpRequestUriTooLong,
                                    21 => {
                                        let e66 = {
                                            let l19 = i32::from(*ptr1.add(16).cast::<u8>());
                                            match l19 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l20 = *ptr1.add(20).cast::<i32>();
                                                        l20 as u32
                                                    };
                                                    Some(e)
                                                }
                                                _ => _rt::invalid_enum_discriminant(),
                                            }
                                        };
                                        V66::HttpRequestHeaderSectionSize(e66)
                                    }
                                    22 => {
                                        let e66 = {
                                            let l21 = i32::from(*ptr1.add(16).cast::<u8>());
                                            match l21 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l22 = i32::from(*ptr1.add(20).cast::<u8>());
                                                        let l26 = i32::from(*ptr1.add(32).cast::<u8>());
                                                        super::super::super::wasi::http::types::FieldSizePayload {
                                                            field_name: match l22 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l23 = *ptr1.add(24).cast::<*mut u8>();
                                                                        let l24 = *ptr1.add(28).cast::<usize>();
                                                                        let len25 = l24;
                                                                        let bytes25 = _rt::Vec::from_raw_parts(
                                                                            l23.cast(),
                                                                            len25,
                                                                            len25,
                                                                        );
                                                                        _rt::string_lift(bytes25)
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                            field_size: match l26 {
                                                                0 => None,
                                                                1 => {
                                                                    let e = {
                                                                        let l27 = *ptr1.add(36).cast::<i32>();
                                                                        l27 as u32
                                                                    };
                                                                    Some(e)
                                                                }
                                                                _ => _rt::invalid_enum_discriminant(),
                                                            },
                                                        }
                                                    };
                                                    Some(e)
                                                }
                                                _ => _rt::invalid_enum_discriminant(),
                                            }
                                        };
                                        V66::HttpRequestHeaderSize(e66)
                                    }
                                    23 => {
                                        let e66 = {
                                            let l28 = i32::from(*ptr1.add(16).cast::<u8>());
                                            match l28 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l29 = *ptr1.add(20).cast::<i32>();
                                                        l29 as u32
                                                    };
                                                    Some(e)
                                                }
                                                _ => _rt::invalid_enum_discriminant(),
                                            }
                                        };
                                        V66::HttpRequestTrailerSectionSize(e66)
                                    }
                                    24 => {
                                        let e66 = {
                                            let l30 = i32::from(*ptr1.add(16).cast::<u8>());
                                            let l34 = i32::from(*ptr1.add(28).cast::<u8>());
                                            super::super::super::wasi::http::types::FieldSizePayload {
                                                field_name: match l30 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l31 = *ptr1.add(20).cast::<*mut u8>();
                                                            let l32 = *ptr1.add(24).cast::<usize>();
                                                            let len33 = l32;
                                                            let bytes33 = _rt::Vec::from_raw_parts(
                                                                l31.cast(),
                                                                len33,
                                                                len33,
                                                            );
                                                            _rt::string_lift(bytes33)
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                },
                                                field_size: match l34 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l35 = *ptr1.add(32).cast::<i32>();
                                                            l35 as u32
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                },
                                            }
                                        };
                                        V66::HttpRequestTrailerSize(e66)
                                    }
                                    25 => V66::HttpResponseIncomplete,
                                    26 => {
                                        let e66 = {
                                            let l36 = i32::from(*ptr1.add(16).cast::<u8>());
                                            match l36 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l37 = *ptr1.add(20).cast::<i32>();
                                                        l37 as u32
                                                    };
                                                    Some(e)
                                                }
                                                _ => _rt::invalid_enum_discriminant(),
                                            }
                                        };
                                        V66::HttpResponseHeaderSectionSize(e66)
                                    }
                                    27 => {
                                        let e66 = {
                                            let l38 = i32::from(*ptr1.add(16).cast::<u8>());
                                            let l42 = i32::from(*ptr1.add(28).cast::<u8>());
                                            super::super::super::wasi::http::types::FieldSizePayload {
                                                field_name: match l38 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l39 = *ptr1.add(20).cast::<*mut u8>();
                                                            let l40 = *ptr1.add(24).cast::<usize>();
                                                            let len41 = l40;
                                                            let bytes41 = _rt::Vec::from_raw_parts(
                                                                l39.cast(),
                                                                len41,
                                                                len41,
                                                            );
                                                            _rt::string_lift(bytes41)
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                },
                                                field_size: match l42 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l43 = *ptr1.add(32).cast::<i32>();
                                                            l43 as u32
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                },
                                            }
                                        };
                                        V66::HttpResponseHeaderSize(e66)
                                    }
                                    28 => {
                                        let e66 = {
                                            let l44 = i32::from(*ptr1.add(16).cast::<u8>());
                                            match l44 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l45 = *ptr1.add(24).cast::<i64>();
                                                        l45 as u64
                                                    };
                                                    Some(e)
                                                }
                                                _ => _rt::invalid_enum_discriminant(),
                                            }
                                        };
                                        V66::HttpResponseBodySize(e66)
                                    }
                                    29 => {
                                        let e66 = {
                                            let l46 = i32::from(*ptr1.add(16).cast::<u8>());
                                            match l46 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l47 = *ptr1.add(20).cast::<i32>();
                                                        l47 as u32
                                                    };
                                                    Some(e)
                                                }
                                                _ => _rt::invalid_enum_discriminant(),
                                            }
                                        };
                                        V66::HttpResponseTrailerSectionSize(e66)
                                    }
                                    30 => {
                                        let e66 = {
                                            let l48 = i32::from(*ptr1.add(16).cast::<u8>());
                                            let l52 = i32::from(*ptr1.add(28).cast::<u8>());
                                            super::super::super::wasi::http::types::FieldSizePayload {
                                                field_name: match l48 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l49 = *ptr1.add(20).cast::<*mut u8>();
                                                            let l50 = *ptr1.add(24).cast::<usize>();
                                                            let len51 = l50;
                                                            let bytes51 = _rt::Vec::from_raw_parts(
                                                                l49.cast(),
                                                                len51,
                                                                len51,
                                                            );
                                                            _rt::string_lift(bytes51)
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                },
                                                field_size: match l52 {
                                                    0 => None,
                                                    1 => {
                                                        let e = {
                                                            let l53 = *ptr1.add(32).cast::<i32>();
                                                            l53 as u32
                                                        };
                                                        Some(e)
                                                    }
                                                    _ => _rt::invalid_enum_discriminant(),
                                                },
                                            }
                                        };
                                        V66::HttpResponseTrailerSize(e66)
                                    }
                                    31 => {
                                        let e66 = {
                                            let l54 = i32::from(*ptr1.add(16).cast::<u8>());
                                            match l54 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l55 = *ptr1.add(20).cast::<*mut u8>();
                                                        let l56 = *ptr1.add(24).cast::<usize>();
                                                        let len57 = l56;
                                                        let bytes57 = _rt::Vec::from_raw_parts(
                                                            l55.cast(),
                                                            len57,
                                                            len57,
                                                        );
                                                        _rt::string_lift(bytes57)
                                                    };
                                                    Some(e)
                                                }
                                                _ => _rt::invalid_enum_discriminant(),
                                            }
                                        };
                                        V66::HttpResponseTransferCoding(e66)
                                    }
                                    32 => {
                                        let e66 = {
                                            let l58 = i32::from(*ptr1.add(16).cast::<u8>());
                                            match l58 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l59 = *ptr1.add(20).cast::<*mut u8>();
                                                        let l60 = *ptr1.add(24).cast::<usize>();
                                                        let len61 = l60;
                                                        let bytes61 = _rt::Vec::from_raw_parts(
                                                            l59.cast(),
                                                            len61,
                                                            len61,
                                                        );
                                                        _rt::string_lift(bytes61)
                                                    };
                                                    Some(e)
                                                }
                                                _ => _rt::invalid_enum_discriminant(),
                                            }
                                        };
                                        V66::HttpResponseContentCoding(e66)
                                    }
                                    33 => V66::HttpResponseTimeout,
                                    34 => V66::HttpUpgradeFailed,
                                    35 => V66::HttpProtocolError,
                                    36 => V66::LoopDetected,
                                    37 => V66::ConfigurationError,
                                    n => {
                                        debug_assert_eq!(n, 38, "invalid enum discriminant");
                                        let e66 = {
                                            let l62 = i32::from(*ptr1.add(16).cast::<u8>());
                                            match l62 {
                                                0 => None,
                                                1 => {
                                                    let e = {
                                                        let l63 = *ptr1.add(20).cast::<*mut u8>();
                                                        let l64 = *ptr1.add(24).cast::<usize>();
                                                        let len65 = l64;
                                                        let bytes65 = _rt::Vec::from_raw_parts(
                                                            l63.cast(),
                                                            len65,
                                                            len65,
                                                        );
                                                        _rt::string_lift(bytes65)
                                                    };
                                                    Some(e)
                                                }
                                                _ => _rt::invalid_enum_discriminant(),
                                            }
                                        };
                                        V66::InternalError(e66)
                                    }
                                };
                                v66
                            };
                            Err(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
        }
    }
    pub mod io {
        /// A poll API intended to let users wait for I/O events on multiple handles
        /// at once.
        #[allow(dead_code, clippy::all)]
        pub mod poll {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            use super::super::super::_rt;
            /// `pollable` epresents a single I/O event which may be ready, or not.
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct Pollable {
                handle: _rt::Resource<Pollable>,
            }
            impl Pollable {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 Pollable {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:io/poll@0.2.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]pollable"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            impl Pollable {
                #[allow(unused_unsafe, clippy::all)]
                /// Return the readiness of a pollable. This function never blocks.
                ///
                /// Returns `true` when the pollable is ready, and `false` otherwise.
                pub fn ready(&self) -> bool {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:io/poll@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]pollable.ready"]
                            fn wit_import(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import((self).handle() as i32);
                        _rt::bool_lift(ret as u8)
                    }
                }
            }
            impl Pollable {
                #[allow(unused_unsafe, clippy::all)]
                /// `block` returns immediately if the pollable is ready, and otherwise
                /// blocks until ready.
                ///
                /// This function is equivalent to calling `poll.poll` on a list
                /// containing only this pollable.
                pub fn block(&self) {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:io/poll@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]pollable.block"]
                            fn wit_import(_: i32);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32);
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Poll for completion on a set of pollables.
            ///
            /// This function takes a list of pollables, which identify I/O sources of
            /// interest, and waits until one or more of the events is ready for I/O.
            ///
            /// The result `list<u32>` contains one or more indices of handles in the
            /// argument list that is ready for I/O.
            ///
            /// If the list contains more elements than can be indexed with a `u32`
            /// value, this function traps.
            ///
            /// A timeout can be implemented by adding a pollable from the
            /// wasi-clocks API to the list.
            ///
            /// This function does not return a `result`; polling in itself does not
            /// do any I/O so it doesn't fail. If any of the I/O sources identified by
            /// the pollables has an error, it is indicated by marking the source as
            /// being reaedy for I/O.
            pub fn poll(in_: &[&Pollable]) -> _rt::Vec<u32> {
                unsafe {
                    #[repr(align(4))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]);
                    let vec0 = in_;
                    let len0 = vec0.len();
                    let layout0 = _rt::alloc::Layout::from_size_align_unchecked(
                        vec0.len() * 4,
                        4,
                    );
                    let result0 = if layout0.size() != 0 {
                        let ptr = _rt::alloc::alloc(layout0).cast::<u8>();
                        if ptr.is_null() {
                            _rt::alloc::handle_alloc_error(layout0);
                        }
                        ptr
                    } else {
                        ::core::ptr::null_mut()
                    };
                    for (i, e) in vec0.into_iter().enumerate() {
                        let base = result0.add(i * 4);
                        {
                            *base.add(0).cast::<i32>() = (e).handle() as i32;
                        }
                    }
                    let ptr1 = ret_area.0.as_mut_ptr().cast::<u8>();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "wasi:io/poll@0.2.0")]
                    extern "C" {
                        #[link_name = "poll"]
                        fn wit_import(_: *mut u8, _: usize, _: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: *mut u8, _: usize, _: *mut u8) {
                        unreachable!()
                    }
                    wit_import(result0, len0, ptr1);
                    let l2 = *ptr1.add(0).cast::<*mut u8>();
                    let l3 = *ptr1.add(4).cast::<usize>();
                    let len4 = l3;
                    if layout0.size() != 0 {
                        _rt::alloc::dealloc(result0.cast(), layout0);
                    }
                    _rt::Vec::from_raw_parts(l2.cast(), len4, len4)
                }
            }
        }
        #[allow(dead_code, clippy::all)]
        pub mod error {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            use super::super::super::_rt;
            /// A resource which represents some error information.
            ///
            /// The only method provided by this resource is `to-debug-string`,
            /// which provides some human-readable information about the error.
            ///
            /// In the `wasi:io` package, this resource is returned through the
            /// `wasi:io/streams/stream-error` type.
            ///
            /// To provide more specific error information, other interfaces may
            /// provide functions to further "downcast" this error into more specific
            /// error information. For example, `error`s returned in streams derived
            /// from filesystem types to be described using the filesystem's own
            /// error-code type, using the function
            /// `wasi:filesystem/types/filesystem-error-code`, which takes a parameter
            /// `borrow<error>` and returns
            /// `option<wasi:filesystem/types/error-code>`.
            ///
            /// The set of functions which can "downcast" an `error` into a more
            /// concrete type is open.
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct Error {
                handle: _rt::Resource<Error>,
            }
            impl Error {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 Error {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:io/error@0.2.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]error"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            impl Error {
                #[allow(unused_unsafe, clippy::all)]
                /// Returns a string that is suitable to assist humans in debugging
                /// this error.
                ///
                /// WARNING: The returned string should not be consumed mechanically!
                /// It may change across platforms, hosts, or other implementation
                /// details. Parsing this string is a major platform-compatibility
                /// hazard.
                pub fn to_debug_string(&self) -> _rt::String {
                    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:io/error@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]error.to-debug-string"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = *ptr0.add(0).cast::<*mut u8>();
                        let l2 = *ptr0.add(4).cast::<usize>();
                        let len3 = l2;
                        let bytes3 = _rt::Vec::from_raw_parts(l1.cast(), len3, len3);
                        _rt::string_lift(bytes3)
                    }
                }
            }
        }
        /// WASI I/O is an I/O abstraction API which is currently focused on providing
        /// stream types.
        ///
        /// In the future, the component model is expected to add built-in stream types;
        /// when it does, they are expected to subsume this API.
        #[allow(dead_code, clippy::all)]
        pub mod streams {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            use super::super::super::_rt;
            pub type Error = super::super::super::wasi::io::error::Error;
            pub type Pollable = super::super::super::wasi::io::poll::Pollable;
            /// An error for input-stream and output-stream operations.
            pub enum StreamError {
                /// The last operation (a write or flush) failed before completion.
                ///
                /// More information is available in the `error` payload.
                LastOperationFailed(Error),
                /// The stream is closed: no more input will be accepted by the
                /// stream. A closed output-stream will return this error on all
                /// future operations.
                Closed,
            }
            impl ::core::fmt::Debug for StreamError {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        StreamError::LastOperationFailed(e) => {
                            f.debug_tuple("StreamError::LastOperationFailed")
                                .field(e)
                                .finish()
                        }
                        StreamError::Closed => {
                            f.debug_tuple("StreamError::Closed").finish()
                        }
                    }
                }
            }
            impl ::core::fmt::Display for StreamError {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    write!(f, "{:?}", self)
                }
            }
            impl std::error::Error for StreamError {}
            /// An input bytestream.
            ///
            /// `input-stream`s are *non-blocking* to the extent practical on underlying
            /// platforms. I/O operations always return promptly; if fewer bytes are
            /// promptly available than requested, they return the number of bytes promptly
            /// available, which could even be zero. To wait for data to be available,
            /// use the `subscribe` function to obtain a `pollable` which can be polled
            /// for using `wasi:io/poll`.
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct InputStream {
                handle: _rt::Resource<InputStream>,
            }
            impl InputStream {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 InputStream {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]input-stream"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            /// An output bytestream.
            ///
            /// `output-stream`s are *non-blocking* to the extent practical on
            /// underlying platforms. Except where specified otherwise, I/O operations also
            /// always return promptly, after the number of bytes that can be written
            /// promptly, which could even be zero. To wait for the stream to be ready to
            /// accept data, the `subscribe` function to obtain a `pollable` which can be
            /// polled for using `wasi:io/poll`.
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct OutputStream {
                handle: _rt::Resource<OutputStream>,
            }
            impl OutputStream {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 OutputStream {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]output-stream"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            impl InputStream {
                #[allow(unused_unsafe, clippy::all)]
                /// Perform a non-blocking read from the stream.
                ///
                /// This function returns a list of bytes containing the read data,
                /// when successful. The returned list will contain up to `len` bytes;
                /// it may return fewer than requested, but not more. The list is
                /// empty when no bytes are available for reading at this time. The
                /// pollable given by `subscribe` will be ready when more bytes are
                /// available.
                ///
                /// This function fails with a `stream-error` when the operation
                /// encounters an error, giving `last-operation-failed`, or when the
                /// stream is closed, giving `closed`.
                ///
                /// When the caller gives a `len` of 0, it represents a request to
                /// read 0 bytes. If the stream is still open, this call should
                /// succeed and return an empty list, or otherwise fail with `closed`.
                ///
                /// The `len` parameter is a `u64`, which could represent a list of u8 which
                /// is not possible to allocate in wasm32, or not desirable to allocate as
                /// as a return value by the callee. The callee may return a list of bytes
                /// less than `len` in size while more bytes are available for reading.
                pub fn read(&self, len: u64) -> Result<_rt::Vec<u8>, StreamError> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]input-stream.read"]
                            fn wit_import(_: i32, _: i64, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i64, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, _rt::as_i64(&len), ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<*mut u8>();
                                    let l3 = *ptr0.add(8).cast::<usize>();
                                    let len4 = l3;
                                    _rt::Vec::from_raw_parts(l2.cast(), len4, len4)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l5 = i32::from(*ptr0.add(4).cast::<u8>());
                                    let v7 = match l5 {
                                        0 => {
                                            let e7 = {
                                                let l6 = *ptr0.add(8).cast::<i32>();
                                                super::super::super::wasi::io::error::Error::from_handle(
                                                    l6 as u32,
                                                )
                                            };
                                            StreamError::LastOperationFailed(e7)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 1, "invalid enum discriminant");
                                            StreamError::Closed
                                        }
                                    };
                                    v7
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl InputStream {
                #[allow(unused_unsafe, clippy::all)]
                /// Read bytes from a stream, after blocking until at least one byte can
                /// be read. Except for blocking, behavior is identical to `read`.
                pub fn blocking_read(
                    &self,
                    len: u64,
                ) -> Result<_rt::Vec<u8>, StreamError> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]input-stream.blocking-read"]
                            fn wit_import(_: i32, _: i64, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i64, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, _rt::as_i64(&len), ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<*mut u8>();
                                    let l3 = *ptr0.add(8).cast::<usize>();
                                    let len4 = l3;
                                    _rt::Vec::from_raw_parts(l2.cast(), len4, len4)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l5 = i32::from(*ptr0.add(4).cast::<u8>());
                                    let v7 = match l5 {
                                        0 => {
                                            let e7 = {
                                                let l6 = *ptr0.add(8).cast::<i32>();
                                                super::super::super::wasi::io::error::Error::from_handle(
                                                    l6 as u32,
                                                )
                                            };
                                            StreamError::LastOperationFailed(e7)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 1, "invalid enum discriminant");
                                            StreamError::Closed
                                        }
                                    };
                                    v7
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl InputStream {
                #[allow(unused_unsafe, clippy::all)]
                /// Skip bytes from a stream. Returns number of bytes skipped.
                ///
                /// Behaves identical to `read`, except instead of returning a list
                /// of bytes, returns the number of bytes consumed from the stream.
                pub fn skip(&self, len: u64) -> Result<u64, StreamError> {
                    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:io/streams@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]input-stream.skip"]
                            fn wit_import(_: i32, _: i64, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i64, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, _rt::as_i64(&len), ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(8).cast::<i64>();
                                    l2 as u64
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = i32::from(*ptr0.add(8).cast::<u8>());
                                    let v5 = match l3 {
                                        0 => {
                                            let e5 = {
                                                let l4 = *ptr0.add(12).cast::<i32>();
                                                super::super::super::wasi::io::error::Error::from_handle(
                                                    l4 as u32,
                                                )
                                            };
                                            StreamError::LastOperationFailed(e5)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 1, "invalid enum discriminant");
                                            StreamError::Closed
                                        }
                                    };
                                    v5
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl InputStream {
                #[allow(unused_unsafe, clippy::all)]
                /// Skip bytes from a stream, after blocking until at least one byte
                /// can be skipped. Except for blocking behavior, identical to `skip`.
                pub fn blocking_skip(&self, len: u64) -> Result<u64, StreamError> {
                    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:io/streams@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]input-stream.blocking-skip"]
                            fn wit_import(_: i32, _: i64, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i64, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, _rt::as_i64(&len), ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(8).cast::<i64>();
                                    l2 as u64
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = i32::from(*ptr0.add(8).cast::<u8>());
                                    let v5 = match l3 {
                                        0 => {
                                            let e5 = {
                                                let l4 = *ptr0.add(12).cast::<i32>();
                                                super::super::super::wasi::io::error::Error::from_handle(
                                                    l4 as u32,
                                                )
                                            };
                                            StreamError::LastOperationFailed(e5)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 1, "invalid enum discriminant");
                                            StreamError::Closed
                                        }
                                    };
                                    v5
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl InputStream {
                #[allow(unused_unsafe, clippy::all)]
                /// Create a `pollable` which will resolve once either the specified stream
                /// has bytes available to read or the other end of the stream has been
                /// closed.
                /// The created `pollable` is a child resource of the `input-stream`.
                /// Implementations may trap if the `input-stream` is dropped before
                /// all derived `pollable`s created with this function are dropped.
                pub fn subscribe(&self) -> Pollable {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]input-stream.subscribe"]
                            fn wit_import(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import((self).handle() as i32);
                        super::super::super::wasi::io::poll::Pollable::from_handle(
                            ret as u32,
                        )
                    }
                }
            }
            impl OutputStream {
                #[allow(unused_unsafe, clippy::all)]
                /// Check readiness for writing. This function never blocks.
                ///
                /// Returns the number of bytes permitted for the next call to `write`,
                /// or an error. Calling `write` with more bytes than this function has
                /// permitted will trap.
                ///
                /// When this function returns 0 bytes, the `subscribe` pollable will
                /// become ready when this function will report at least 1 byte, or an
                /// error.
                pub fn check_write(&self) -> Result<u64, StreamError> {
                    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:io/streams@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]output-stream.check-write"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(8).cast::<i64>();
                                    l2 as u64
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = i32::from(*ptr0.add(8).cast::<u8>());
                                    let v5 = match l3 {
                                        0 => {
                                            let e5 = {
                                                let l4 = *ptr0.add(12).cast::<i32>();
                                                super::super::super::wasi::io::error::Error::from_handle(
                                                    l4 as u32,
                                                )
                                            };
                                            StreamError::LastOperationFailed(e5)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 1, "invalid enum discriminant");
                                            StreamError::Closed
                                        }
                                    };
                                    v5
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl OutputStream {
                #[allow(unused_unsafe, clippy::all)]
                /// Perform a write. This function never blocks.
                ///
                /// Precondition: check-write gave permit of Ok(n) and contents has a
                /// length of less than or equal to n. Otherwise, this function will trap.
                ///
                /// returns Err(closed) without writing if the stream has closed since
                /// the last call to check-write provided a permit.
                pub fn write(&self, contents: &[u8]) -> Result<(), StreamError> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let vec0 = contents;
                        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:io/streams@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]output-stream.write"]
                            fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0.cast_mut(), len0, ptr1);
                        let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                        match l2 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = i32::from(*ptr1.add(4).cast::<u8>());
                                    let v5 = match l3 {
                                        0 => {
                                            let e5 = {
                                                let l4 = *ptr1.add(8).cast::<i32>();
                                                super::super::super::wasi::io::error::Error::from_handle(
                                                    l4 as u32,
                                                )
                                            };
                                            StreamError::LastOperationFailed(e5)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 1, "invalid enum discriminant");
                                            StreamError::Closed
                                        }
                                    };
                                    v5
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl OutputStream {
                #[allow(unused_unsafe, clippy::all)]
                /// Perform a write of up to 4096 bytes, and then flush the stream. Block
                /// until all of these operations are complete, or an error occurs.
                ///
                /// This is a convenience wrapper around the use of `check-write`,
                /// `subscribe`, `write`, and `flush`, and is implemented with the
                /// following pseudo-code:
                ///
                /// ```text
                /// let pollable = this.subscribe();
                /// while !contents.is_empty() {
                /// // Wait for the stream to become writable
                /// poll-one(pollable);
                /// let Ok(n) = this.check-write(); // eliding error handling
                /// let len = min(n, contents.len());
                /// let (chunk, rest) = contents.split_at(len);
                /// this.write(chunk  );            // eliding error handling
                /// contents = rest;
                /// }
                /// this.flush();
                /// // Wait for completion of `flush`
                /// poll-one(pollable);
                /// // Check for any errors that arose during `flush`
                /// let _ = this.check-write();         // eliding error handling
                /// ```
                pub fn blocking_write_and_flush(
                    &self,
                    contents: &[u8],
                ) -> Result<(), StreamError> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let vec0 = contents;
                        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:io/streams@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]output-stream.blocking-write-and-flush"]
                            fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0.cast_mut(), len0, ptr1);
                        let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                        match l2 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = i32::from(*ptr1.add(4).cast::<u8>());
                                    let v5 = match l3 {
                                        0 => {
                                            let e5 = {
                                                let l4 = *ptr1.add(8).cast::<i32>();
                                                super::super::super::wasi::io::error::Error::from_handle(
                                                    l4 as u32,
                                                )
                                            };
                                            StreamError::LastOperationFailed(e5)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 1, "invalid enum discriminant");
                                            StreamError::Closed
                                        }
                                    };
                                    v5
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl OutputStream {
                #[allow(unused_unsafe, clippy::all)]
                /// Request to flush buffered output. This function never blocks.
                ///
                /// This tells the output-stream that the caller intends any buffered
                /// output to be flushed. the output which is expected to be flushed
                /// is all that has been passed to `write` prior to this call.
                ///
                /// Upon calling this function, the `output-stream` will not accept any
                /// writes (`check-write` will return `ok(0)`) until the flush has
                /// completed. The `subscribe` pollable will become ready when the
                /// flush has completed and the stream can accept more writes.
                pub fn flush(&self) -> Result<(), StreamError> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]output-stream.flush"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(4).cast::<u8>());
                                    let v4 = match l2 {
                                        0 => {
                                            let e4 = {
                                                let l3 = *ptr0.add(8).cast::<i32>();
                                                super::super::super::wasi::io::error::Error::from_handle(
                                                    l3 as u32,
                                                )
                                            };
                                            StreamError::LastOperationFailed(e4)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 1, "invalid enum discriminant");
                                            StreamError::Closed
                                        }
                                    };
                                    v4
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl OutputStream {
                #[allow(unused_unsafe, clippy::all)]
                /// Request to flush buffered output, and block until flush completes
                /// and stream is ready for writing again.
                pub fn blocking_flush(&self) -> Result<(), StreamError> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]output-stream.blocking-flush"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(4).cast::<u8>());
                                    let v4 = match l2 {
                                        0 => {
                                            let e4 = {
                                                let l3 = *ptr0.add(8).cast::<i32>();
                                                super::super::super::wasi::io::error::Error::from_handle(
                                                    l3 as u32,
                                                )
                                            };
                                            StreamError::LastOperationFailed(e4)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 1, "invalid enum discriminant");
                                            StreamError::Closed
                                        }
                                    };
                                    v4
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl OutputStream {
                #[allow(unused_unsafe, clippy::all)]
                /// Create a `pollable` which will resolve once the output-stream
                /// is ready for more writing, or an error has occured. When this
                /// pollable is ready, `check-write` will return `ok(n)` with n>0, or an
                /// error.
                ///
                /// If the stream is closed, this pollable is always ready immediately.
                ///
                /// The created `pollable` is a child resource of the `output-stream`.
                /// Implementations may trap if the `output-stream` is dropped before
                /// all derived `pollable`s created with this function are dropped.
                pub fn subscribe(&self) -> Pollable {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]output-stream.subscribe"]
                            fn wit_import(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import((self).handle() as i32);
                        super::super::super::wasi::io::poll::Pollable::from_handle(
                            ret as u32,
                        )
                    }
                }
            }
            impl OutputStream {
                #[allow(unused_unsafe, clippy::all)]
                /// Write zeroes to a stream.
                ///
                /// this should be used precisely like `write` with the exact same
                /// preconditions (must use check-write first), but instead of
                /// passing a list of bytes, you simply pass the number of zero-bytes
                /// that should be written.
                pub fn write_zeroes(&self, len: u64) -> Result<(), StreamError> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]output-stream.write-zeroes"]
                            fn wit_import(_: i32, _: i64, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i64, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, _rt::as_i64(&len), ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(4).cast::<u8>());
                                    let v4 = match l2 {
                                        0 => {
                                            let e4 = {
                                                let l3 = *ptr0.add(8).cast::<i32>();
                                                super::super::super::wasi::io::error::Error::from_handle(
                                                    l3 as u32,
                                                )
                                            };
                                            StreamError::LastOperationFailed(e4)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 1, "invalid enum discriminant");
                                            StreamError::Closed
                                        }
                                    };
                                    v4
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl OutputStream {
                #[allow(unused_unsafe, clippy::all)]
                /// Perform a write of up to 4096 zeroes, and then flush the stream.
                /// Block until all of these operations are complete, or an error
                /// occurs.
                ///
                /// This is a convenience wrapper around the use of `check-write`,
                /// `subscribe`, `write-zeroes`, and `flush`, and is implemented with
                /// the following pseudo-code:
                ///
                /// ```text
                /// let pollable = this.subscribe();
                /// while num_zeroes != 0 {
                /// // Wait for the stream to become writable
                /// poll-one(pollable);
                /// let Ok(n) = this.check-write(); // eliding error handling
                /// let len = min(n, num_zeroes);
                /// this.write-zeroes(len);         // eliding error handling
                /// num_zeroes -= len;
                /// }
                /// this.flush();
                /// // Wait for completion of `flush`
                /// poll-one(pollable);
                /// // Check for any errors that arose during `flush`
                /// let _ = this.check-write();         // eliding error handling
                /// ```
                pub fn blocking_write_zeroes_and_flush(
                    &self,
                    len: u64,
                ) -> Result<(), StreamError> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:io/streams@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]output-stream.blocking-write-zeroes-and-flush"]
                            fn wit_import(_: i32, _: i64, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i64, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, _rt::as_i64(&len), ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(4).cast::<u8>());
                                    let v4 = match l2 {
                                        0 => {
                                            let e4 = {
                                                let l3 = *ptr0.add(8).cast::<i32>();
                                                super::super::super::wasi::io::error::Error::from_handle(
                                                    l3 as u32,
                                                )
                                            };
                                            StreamError::LastOperationFailed(e4)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 1, "invalid enum discriminant");
                                            StreamError::Closed
                                        }
                                    };
                                    v4
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl OutputStream {
                #[allow(unused_unsafe, clippy::all)]
                /// Read from one stream and write to another.
                ///
                /// The behavior of splice is equivelant to:
                /// 1. calling `check-write` on the `output-stream`
                /// 2. calling `read` on the `input-stream` with the smaller of the
                /// `check-write` permitted length and the `len` provided to `splice`
                /// 3. calling `write` on the `output-stream` with that read data.
                ///
                /// Any error reported by the call to `check-write`, `read`, or
                /// `write` ends the splice and reports that error.
                ///
                /// This function returns the number of bytes transferred; it may be less
                /// than `len`.
                pub fn splice(
                    &self,
                    src: &InputStream,
                    len: u64,
                ) -> Result<u64, StreamError> {
                    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:io/streams@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]output-stream.splice"]
                            fn wit_import(_: i32, _: i32, _: i64, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i32, _: i64, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            (src).handle() as i32,
                            _rt::as_i64(&len),
                            ptr0,
                        );
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(8).cast::<i64>();
                                    l2 as u64
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = i32::from(*ptr0.add(8).cast::<u8>());
                                    let v5 = match l3 {
                                        0 => {
                                            let e5 = {
                                                let l4 = *ptr0.add(12).cast::<i32>();
                                                super::super::super::wasi::io::error::Error::from_handle(
                                                    l4 as u32,
                                                )
                                            };
                                            StreamError::LastOperationFailed(e5)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 1, "invalid enum discriminant");
                                            StreamError::Closed
                                        }
                                    };
                                    v5
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl OutputStream {
                #[allow(unused_unsafe, clippy::all)]
                /// Read from one stream and write to another, with blocking.
                ///
                /// This is similar to `splice`, except that it blocks until the
                /// `output-stream` is ready for writing, and the `input-stream`
                /// is ready for reading, before performing the `splice`.
                pub fn blocking_splice(
                    &self,
                    src: &InputStream,
                    len: u64,
                ) -> Result<u64, StreamError> {
                    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:io/streams@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]output-stream.blocking-splice"]
                            fn wit_import(_: i32, _: i32, _: i64, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: i32, _: i64, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import(
                            (self).handle() as i32,
                            (src).handle() as i32,
                            _rt::as_i64(&len),
                            ptr0,
                        );
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(8).cast::<i64>();
                                    l2 as u64
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = i32::from(*ptr0.add(8).cast::<u8>());
                                    let v5 = match l3 {
                                        0 => {
                                            let e5 = {
                                                let l4 = *ptr0.add(12).cast::<i32>();
                                                super::super::super::wasi::io::error::Error::from_handle(
                                                    l4 as u32,
                                                )
                                            };
                                            StreamError::LastOperationFailed(e5)
                                        }
                                        n => {
                                            debug_assert_eq!(n, 1, "invalid enum discriminant");
                                            StreamError::Closed
                                        }
                                    };
                                    v5
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
        }
    }
    pub mod keyvalue {
        #[allow(dead_code, clippy::all)]
        pub mod wasi_keyvalue_error {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            use super::super::super::_rt;
            /// An error resource type for keyvalue operations.
            ///
            /// Common errors:
            /// - Connectivity errors (e.g. network errors): when the client cannot establish
            /// a connection to the keyvalue service.
            /// - Authentication and Authorization errors: when the client fails to authenticate
            /// or does not have the required permissions to perform the operation.
            /// - Data errors: when the client sends incompatible or corrupted data.
            /// - Resource errors: when the system runs out of resources (e.g. memory).
            /// - Internal errors: unexpected errors on the server side.
            ///
            /// Currently, this provides only one function to return a string representation
            /// of the error. In the future, this will be extended to provide more information
            /// about the error.
            /// Soon: switch to `resource error { ... }`
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct Error {
                handle: _rt::Resource<Error>,
            }
            impl Error {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 Error {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(
                            wasm_import_module = "wasi:keyvalue/wasi-keyvalue-error@0.1.0"
                        )]
                        extern "C" {
                            #[link_name = "[resource-drop]error"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            impl Error {
                #[allow(unused_unsafe, clippy::all)]
                pub fn trace(&self) -> _rt::String {
                    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:keyvalue/wasi-keyvalue-error@0.1.0"
                        )]
                        extern "C" {
                            #[link_name = "[method]error.trace"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = *ptr0.add(0).cast::<*mut u8>();
                        let l2 = *ptr0.add(4).cast::<usize>();
                        let len3 = l2;
                        let bytes3 = _rt::Vec::from_raw_parts(l1.cast(), len3, len3);
                        _rt::string_lift(bytes3)
                    }
                }
            }
        }
        /// A generic keyvalue interface for WASI.
        #[allow(dead_code, 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 InputStream = super::super::super::wasi::io::streams::InputStream;
            pub type OutputStream = super::super::super::wasi::io::streams::OutputStream;
            pub type Error = super::super::super::wasi::keyvalue::wasi_keyvalue_error::Error;
            /// A bucket is a collection of key-value pairs. Each key-value pair is stored
            /// as a entry in the bucket, and the bucket itself acts as a collection of all
            /// these entries.
            ///
            /// It is worth noting that the exact terminology for bucket in key-value stores
            /// can very depending on the specific implementation. For example,
            /// 1. Amazon DynamoDB calls a collection of key-value pairs a table
            /// 2. Redis has hashes, sets, and sorted sets as different types of collections
            /// 3. Cassandra calls a collection of key-value pairs a column family
            /// 4. MongoDB calls a collection of key-value pairs a collection
            /// 5. Riak calls a collection of key-value pairs a bucket
            /// 6. Memcached calls a collection of key-value pairs a slab
            /// 7. Azure Cosmos DB calls a collection of key-value pairs a container
            ///
            /// In this interface, we use the term `bucket` to refer to a collection of key-value
            /// Soon: switch to `resource bucket { ... }`
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct Bucket {
                handle: _rt::Resource<Bucket>,
            }
            impl Bucket {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 Bucket {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:keyvalue/types@0.1.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]bucket"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            /// A key is a unique identifier for a value in a bucket. The key is used to
            /// retrieve the value from the bucket.
            pub type Key = _rt::String;
            /// A value is the data stored in a key-value pair. The value can be of any type
            /// that can be represented in a byte array. It provides a way to write the value
            /// to the output-stream defined in the `wasi-io` interface.
            /// Soon: switch to `resource value { ... }`
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct OutgoingValue {
                handle: _rt::Resource<OutgoingValue>,
            }
            impl OutgoingValue {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 OutgoingValue {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:keyvalue/types@0.1.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]outgoing-value"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            pub type OutgoingValueBodyAsync = OutputStream;
            pub type OutgoingValueBodySync = _rt::Vec<u8>;
            /// A incoming-value is a wrapper around a value. It provides a way to read the value
            /// from the `input-stream` defined in the `wasi-io` interface.
            ///
            /// The incoming-value provides two ways to consume the value:
            /// 1. `incoming-value-consume-sync` consumes the value synchronously and returns the
            /// value as a `list<u8>`.
            /// 2. `incoming-value-consume-async` consumes the value asynchronously and returns the
            /// value as an `input-stream`.
            /// In addition, it provides a `incoming-value-size` function to get the size of the value.
            /// This is useful when the value is large and the caller wants to allocate a buffer of
            /// the right size to consume the value.
            /// Soon: switch to `resource incoming-value { ... }`
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct IncomingValue {
                handle: _rt::Resource<IncomingValue>,
            }
            impl IncomingValue {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 IncomingValue {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:keyvalue/types@0.1.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]incoming-value"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            pub type IncomingValueAsyncBody = InputStream;
            pub type IncomingValueSyncBody = _rt::Vec<u8>;
            impl Bucket {
                #[allow(unused_unsafe, clippy::all)]
                /// Opens a bucket with the given name.
                ///
                /// If any error occurs, including if the bucket does not exist, it returns an `Err(error)`.
                pub fn open_bucket(name: &str) -> Result<Bucket, Error> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 8],
                        );
                        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:keyvalue/types@0.1.0")]
                        extern "C" {
                            #[link_name = "[static]bucket.open-bucket"]
                            fn wit_import(_: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: *mut u8, _: usize, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import(ptr0.cast_mut(), len0, ptr1);
                        let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                        match l2 {
                            0 => {
                                let e = {
                                    let l3 = *ptr1.add(4).cast::<i32>();
                                    Bucket::from_handle(l3 as u32)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l4 = *ptr1.add(4).cast::<i32>();
                                    super::super::super::wasi::keyvalue::wasi_keyvalue_error::Error::from_handle(
                                        l4 as u32,
                                    )
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl OutgoingValue {
                #[allow(unused_unsafe, clippy::all)]
                pub fn new_outgoing_value() -> OutgoingValue {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:keyvalue/types@0.1.0")]
                        extern "C" {
                            #[link_name = "[static]outgoing-value.new-outgoing-value"]
                            fn wit_import() -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import() -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import();
                        OutgoingValue::from_handle(ret as u32)
                    }
                }
            }
            impl OutgoingValue {
                #[allow(unused_unsafe, clippy::all)]
                /// Writes the value to the output-stream asynchronously.
                /// If any other error occurs, it returns an `Err(error)`.
                pub fn outgoing_value_write_body_async(
                    &self,
                ) -> Result<OutgoingValueBodyAsync, Error> {
                    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:keyvalue/types@0.1.0")]
                        extern "C" {
                            #[link_name = "[method]outgoing-value.outgoing-value-write-body-async"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<i32>();
                                    super::super::super::wasi::io::streams::OutputStream::from_handle(
                                        l2 as u32,
                                    )
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = *ptr0.add(4).cast::<i32>();
                                    super::super::super::wasi::keyvalue::wasi_keyvalue_error::Error::from_handle(
                                        l3 as u32,
                                    )
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl OutgoingValue {
                #[allow(unused_unsafe, clippy::all)]
                /// Writes the value to the output-stream synchronously.
                /// If any other error occurs, it returns an `Err(error)`.
                pub fn outgoing_value_write_body_sync(
                    &self,
                    value: &OutgoingValueBodySync,
                ) -> Result<(), Error> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 8],
                        );
                        let vec0 = value;
                        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:keyvalue/types@0.1.0")]
                        extern "C" {
                            #[link_name = "[method]outgoing-value.outgoing-value-write-body-sync"]
                            fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0.cast_mut(), len0, ptr1);
                        let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                        match l2 {
                            0 => {
                                let e = ();
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = *ptr1.add(4).cast::<i32>();
                                    super::super::super::wasi::keyvalue::wasi_keyvalue_error::Error::from_handle(
                                        l3 as u32,
                                    )
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl IncomingValue {
                #[allow(unused_unsafe, clippy::all)]
                /// Consumes the value synchronously and returns the value as a list of bytes.
                /// If any other error occurs, it returns an `Err(error)`.
                pub fn incoming_value_consume_sync(
                    &self,
                ) -> Result<IncomingValueSyncBody, Error> {
                    unsafe {
                        #[repr(align(4))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 12],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:keyvalue/types@0.1.0")]
                        extern "C" {
                            #[link_name = "[method]incoming-value.incoming-value-consume-sync"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<*mut u8>();
                                    let l3 = *ptr0.add(8).cast::<usize>();
                                    let len4 = l3;
                                    _rt::Vec::from_raw_parts(l2.cast(), len4, len4)
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l5 = *ptr0.add(4).cast::<i32>();
                                    super::super::super::wasi::keyvalue::wasi_keyvalue_error::Error::from_handle(
                                        l5 as u32,
                                    )
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl IncomingValue {
                #[allow(unused_unsafe, clippy::all)]
                /// Consumes the value asynchronously and returns the value as an `input-stream`.
                /// If any other error occurs, it returns an `Err(error)`.
                pub fn incoming_value_consume_async(
                    &self,
                ) -> Result<IncomingValueAsyncBody, Error> {
                    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:keyvalue/types@0.1.0")]
                        extern "C" {
                            #[link_name = "[method]incoming-value.incoming-value-consume-async"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(4).cast::<i32>();
                                    super::super::super::wasi::io::streams::InputStream::from_handle(
                                        l2 as u32,
                                    )
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = *ptr0.add(4).cast::<i32>();
                                    super::super::super::wasi::keyvalue::wasi_keyvalue_error::Error::from_handle(
                                        l3 as u32,
                                    )
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl IncomingValue {
                #[allow(unused_unsafe, clippy::all)]
                /// The size of the value in bytes.
                /// If the size is unknown or unavailable, this function returns an `Err(error)`.
                pub fn incoming_value_size(&self) -> Result<u64, Error> {
                    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:keyvalue/types@0.1.0")]
                        extern "C" {
                            #[link_name = "[method]incoming-value.incoming-value-size"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = *ptr0.add(8).cast::<i64>();
                                    l2 as u64
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l3 = *ptr0.add(8).cast::<i32>();
                                    super::super::super::wasi::keyvalue::wasi_keyvalue_error::Error::from_handle(
                                        l3 as u32,
                                    )
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
        }
        /// A keyvalue interface that provides eventually consistent batch operations.
        ///
        /// A batch operation is an operation that operates on multiple keys at once.
        ///
        /// Batch operations are useful for reducing network round-trip time. For example,
        /// if you want to get the values associated with 100 keys, you can either do 100 get
        /// operations or you can do 1 batch get operation. The batch operation is
        /// faster because it only needs to make 1 network call instead of 100.
        ///
        /// A batch operation does not guarantee atomicity, meaning that if the batch
        /// operation fails, some of the keys may have been modified and some may not.
        /// Transactional operations are being worked on and will be added in the future to
        /// provide atomicity.
        ///
        /// Data consistency in a key value store refers to the gaurantee that once a
        /// write operation completes, all subsequent read operations will return the
        /// value that was written.
        ///
        /// The level of consistency in batch operations is **eventual consistency**, the same
        /// with the readwrite interface. This interface does not guarantee strong consistency,
        /// meaning that if a write operation completes, subsequent read operations may not return
        /// the value that was written.
        #[allow(dead_code, clippy::all)]
        pub mod eventual_batch {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            use super::super::super::_rt;
            pub type Bucket = super::super::super::wasi::keyvalue::types::Bucket;
            pub type Error = super::super::super::wasi::keyvalue::types::Error;
            pub type Key = super::super::super::wasi::keyvalue::types::Key;
            pub type IncomingValue = super::super::super::wasi::keyvalue::types::IncomingValue;
            pub type OutgoingValue = super::super::super::wasi::keyvalue::types::OutgoingValue;
            #[allow(unused_unsafe, clippy::all)]
            /// Get the values associated with the keys in the bucket. It returns a list of
            /// incoming-value that can be consumed to get the value associated with the key.
            ///
            /// If any of the keys do not exist in the bucket, it returns a `none` value for
            /// that key in the list.
            ///
            /// Note that the key-value pairs are guaranteed to be returned in the same order
            ///
            /// MAY show an out-of-date value if there are concurrent writes to the bucket.
            ///
            /// If any other error occurs, it returns an `Err(error)`.
            pub fn get_many(
                bucket: &Bucket,
                keys: &[Key],
            ) -> Result<_rt::Vec<Option<IncomingValue>>, Error> {
                unsafe {
                    #[repr(align(4))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]);
                    let vec1 = keys;
                    let len1 = vec1.len();
                    let layout1 = _rt::alloc::Layout::from_size_align_unchecked(
                        vec1.len() * 8,
                        4,
                    );
                    let result1 = if layout1.size() != 0 {
                        let ptr = _rt::alloc::alloc(layout1).cast::<u8>();
                        if ptr.is_null() {
                            _rt::alloc::handle_alloc_error(layout1);
                        }
                        ptr
                    } else {
                        ::core::ptr::null_mut()
                    };
                    for (i, e) in vec1.into_iter().enumerate() {
                        let base = result1.add(i * 8);
                        {
                            let vec0 = e;
                            let ptr0 = vec0.as_ptr().cast::<u8>();
                            let len0 = vec0.len();
                            *base.add(4).cast::<usize>() = len0;
                            *base.add(0).cast::<*mut u8>() = ptr0.cast_mut();
                        }
                    }
                    let ptr2 = ret_area.0.as_mut_ptr().cast::<u8>();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "wasi:keyvalue/eventual-batch@0.1.0")]
                    extern "C" {
                        #[link_name = "get-many"]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8) {
                        unreachable!()
                    }
                    wit_import((bucket).handle() as i32, result1, len1, ptr2);
                    let l3 = i32::from(*ptr2.add(0).cast::<u8>());
                    if layout1.size() != 0 {
                        _rt::alloc::dealloc(result1.cast(), layout1);
                    }
                    match l3 {
                        0 => {
                            let e = {
                                let l4 = *ptr2.add(4).cast::<*mut u8>();
                                let l5 = *ptr2.add(8).cast::<usize>();
                                let base8 = l4;
                                let len8 = l5;
                                let mut result8 = _rt::Vec::with_capacity(len8);
                                for i in 0..len8 {
                                    let base = base8.add(i * 8);
                                    let e8 = {
                                        let l6 = i32::from(*base.add(0).cast::<u8>());
                                        match l6 {
                                            0 => None,
                                            1 => {
                                                let e = {
                                                    let l7 = *base.add(4).cast::<i32>();
                                                    super::super::super::wasi::keyvalue::types::IncomingValue::from_handle(
                                                        l7 as u32,
                                                    )
                                                };
                                                Some(e)
                                            }
                                            _ => _rt::invalid_enum_discriminant(),
                                        }
                                    };
                                    result8.push(e8);
                                }
                                _rt::cabi_dealloc(base8, len8 * 8, 4);
                                result8
                            };
                            Ok(e)
                        }
                        1 => {
                            let e = {
                                let l9 = *ptr2.add(4).cast::<i32>();
                                super::super::super::wasi::keyvalue::wasi_keyvalue_error::Error::from_handle(
                                    l9 as u32,
                                )
                            };
                            Err(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Get all the keys in the bucket. It returns a list of keys.
            ///
            /// Note that the keys are not guaranteed to be returned in any particular order.
            ///
            /// If the bucket is empty, it returns an empty list.
            ///
            /// MAY show an out-of-date list of keys if there are concurrent writes to the bucket.
            ///
            /// If any error occurs, it returns an `Err(error)`.
            pub fn keys(bucket: &Bucket) -> Result<_rt::Vec<Key>, Error> {
                unsafe {
                    #[repr(align(4))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]);
                    let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "wasi:keyvalue/eventual-batch@0.1.0")]
                    extern "C" {
                        #[link_name = "keys"]
                        fn wit_import(_: i32, _: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i32, _: *mut u8) {
                        unreachable!()
                    }
                    wit_import((bucket).handle() as i32, ptr0);
                    let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                    match l1 {
                        0 => {
                            let e = {
                                let l2 = *ptr0.add(4).cast::<*mut u8>();
                                let l3 = *ptr0.add(8).cast::<usize>();
                                let base7 = l2;
                                let len7 = l3;
                                let mut result7 = _rt::Vec::with_capacity(len7);
                                for i in 0..len7 {
                                    let base = base7.add(i * 8);
                                    let e7 = {
                                        let l4 = *base.add(0).cast::<*mut u8>();
                                        let l5 = *base.add(4).cast::<usize>();
                                        let len6 = l5;
                                        let bytes6 = _rt::Vec::from_raw_parts(
                                            l4.cast(),
                                            len6,
                                            len6,
                                        );
                                        _rt::string_lift(bytes6)
                                    };
                                    result7.push(e7);
                                }
                                _rt::cabi_dealloc(base7, len7 * 8, 4);
                                result7
                            };
                            Ok(e)
                        }
                        1 => {
                            let e = {
                                let l8 = *ptr0.add(4).cast::<i32>();
                                super::super::super::wasi::keyvalue::wasi_keyvalue_error::Error::from_handle(
                                    l8 as u32,
                                )
                            };
                            Err(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Set the values associated with the keys in the bucket. If the key already
            /// exists in the bucket, it overwrites the value.
            ///
            /// Note that the key-value pairs are not guaranteed to be set in the order
            /// they are provided.
            ///
            /// If any of the keys do not exist in the bucket, it creates a new key-value pair.
            ///
            /// If any other error occurs, it returns an `Err(error)`. When an error occurs, it
            /// does not rollback the key-value pairs that were already set. Thus, this batch operation
            /// does not guarantee atomicity, implying that some key-value pairs could be
            /// set while others might fail.
            ///
            /// Other concurrent operations may also be able to see the partial results.
            pub fn set_many(
                bucket: &Bucket,
                key_values: &[(Key, &OutgoingValue)],
            ) -> Result<(), Error> {
                unsafe {
                    #[repr(align(4))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]);
                    let vec2 = key_values;
                    let len2 = vec2.len();
                    let layout2 = _rt::alloc::Layout::from_size_align_unchecked(
                        vec2.len() * 12,
                        4,
                    );
                    let result2 = if layout2.size() != 0 {
                        let ptr = _rt::alloc::alloc(layout2).cast::<u8>();
                        if ptr.is_null() {
                            _rt::alloc::handle_alloc_error(layout2);
                        }
                        ptr
                    } else {
                        ::core::ptr::null_mut()
                    };
                    for (i, e) in vec2.into_iter().enumerate() {
                        let base = result2.add(i * 12);
                        {
                            let (t0_0, t0_1) = e;
                            let vec1 = t0_0;
                            let ptr1 = vec1.as_ptr().cast::<u8>();
                            let len1 = vec1.len();
                            *base.add(4).cast::<usize>() = len1;
                            *base.add(0).cast::<*mut u8>() = ptr1.cast_mut();
                            *base.add(8).cast::<i32>() = (t0_1).handle() as i32;
                        }
                    }
                    let ptr3 = ret_area.0.as_mut_ptr().cast::<u8>();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "wasi:keyvalue/eventual-batch@0.1.0")]
                    extern "C" {
                        #[link_name = "set-many"]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8) {
                        unreachable!()
                    }
                    wit_import((bucket).handle() as i32, result2, len2, ptr3);
                    let l4 = i32::from(*ptr3.add(0).cast::<u8>());
                    if layout2.size() != 0 {
                        _rt::alloc::dealloc(result2.cast(), layout2);
                    }
                    match l4 {
                        0 => {
                            let e = ();
                            Ok(e)
                        }
                        1 => {
                            let e = {
                                let l5 = *ptr3.add(4).cast::<i32>();
                                super::super::super::wasi::keyvalue::wasi_keyvalue_error::Error::from_handle(
                                    l5 as u32,
                                )
                            };
                            Err(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Delete the key-value pairs associated with the keys in the bucket.
            ///
            /// Note that the key-value pairs are not guaranteed to be deleted in the order
            /// they are provided.
            ///
            /// If any of the keys do not exist in the bucket, it skips the key.
            ///
            /// If any other error occurs, it returns an `Err(error)`. When an error occurs, it
            /// does not rollback the key-value pairs that were already deleted. Thus, this batch operation
            /// does not guarantee atomicity, implying that some key-value pairs could be
            /// deleted while others might fail.
            ///
            /// Other concurrent operations may also be able to see the partial results.
            pub fn delete_many(bucket: &Bucket, keys: &[Key]) -> Result<(), Error> {
                unsafe {
                    #[repr(align(4))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]);
                    let vec1 = keys;
                    let len1 = vec1.len();
                    let layout1 = _rt::alloc::Layout::from_size_align_unchecked(
                        vec1.len() * 8,
                        4,
                    );
                    let result1 = if layout1.size() != 0 {
                        let ptr = _rt::alloc::alloc(layout1).cast::<u8>();
                        if ptr.is_null() {
                            _rt::alloc::handle_alloc_error(layout1);
                        }
                        ptr
                    } else {
                        ::core::ptr::null_mut()
                    };
                    for (i, e) in vec1.into_iter().enumerate() {
                        let base = result1.add(i * 8);
                        {
                            let vec0 = e;
                            let ptr0 = vec0.as_ptr().cast::<u8>();
                            let len0 = vec0.len();
                            *base.add(4).cast::<usize>() = len0;
                            *base.add(0).cast::<*mut u8>() = ptr0.cast_mut();
                        }
                    }
                    let ptr2 = ret_area.0.as_mut_ptr().cast::<u8>();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "wasi:keyvalue/eventual-batch@0.1.0")]
                    extern "C" {
                        #[link_name = "delete-many"]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8) {
                        unreachable!()
                    }
                    wit_import((bucket).handle() as i32, result1, len1, ptr2);
                    let l3 = i32::from(*ptr2.add(0).cast::<u8>());
                    if layout1.size() != 0 {
                        _rt::alloc::dealloc(result1.cast(), layout1);
                    }
                    match l3 {
                        0 => {
                            let e = ();
                            Ok(e)
                        }
                        1 => {
                            let e = {
                                let l4 = *ptr2.add(4).cast::<i32>();
                                super::super::super::wasi::keyvalue::wasi_keyvalue_error::Error::from_handle(
                                    l4 as u32,
                                )
                            };
                            Err(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
        }
        /// A keyvalue interface that provides eventually consistent CRUD operations.
        ///
        /// A CRUD operation is an operation that acts on a single key-value pair.
        ///
        /// The value in the key-value pair is defined as a `u8` byte array and the intention
        /// is that it is the common denominator for all data types defined by different
        /// key-value stores to handle data, ensuring compatibility between different
        /// key-value stores. Note: the clients will be expecting serialization/deserialization overhead
        /// to be handled by the key-value store. The value could be a serialized object from
        /// JSON, HTML or vendor-specific data types like AWS S3 objects.
        ///
        /// Data consistency in a key value store refers to the gaurantee that once a
        /// write operation completes, all subsequent read operations will return the
        /// value that was written.
        ///
        /// The level of consistency in readwrite interfaces is **eventual consistency**,
        /// which means that if a write operation completes successfully, all subsequent
        /// read operations will eventually return the value that was written. In other words,
        /// if we pause the updates to the system, the system eventually will return
        /// the last updated value for read.
        #[allow(dead_code, clippy::all)]
        pub mod eventual {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            use super::super::super::_rt;
            pub type Bucket = super::super::super::wasi::keyvalue::types::Bucket;
            pub type Error = super::super::super::wasi::keyvalue::types::Error;
            pub type IncomingValue = super::super::super::wasi::keyvalue::types::IncomingValue;
            pub type Key = super::super::super::wasi::keyvalue::types::Key;
            pub type OutgoingValue = super::super::super::wasi::keyvalue::types::OutgoingValue;
            #[allow(unused_unsafe, clippy::all)]
            /// Get the value associated with the key in the bucket.
            ///
            /// The value is returned as an option. If the key-value pair exists in the
            /// bucket, it returns `Ok(value)`. If the key does not exist in the
            /// bucket, it returns `Ok(none)`.
            ///
            /// If any other error occurs, it returns an `Err(error)`.
            pub fn get(
                bucket: &Bucket,
                key: &Key,
            ) -> Result<Option<IncomingValue>, Error> {
                unsafe {
                    #[repr(align(4))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 12]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 12]);
                    let vec0 = key;
                    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:keyvalue/eventual@0.1.0")]
                    extern "C" {
                        #[link_name = "get"]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8) {
                        unreachable!()
                    }
                    wit_import((bucket).handle() as i32, ptr0.cast_mut(), len0, ptr1);
                    let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                    match l2 {
                        0 => {
                            let e = {
                                let l3 = i32::from(*ptr1.add(4).cast::<u8>());
                                match l3 {
                                    0 => None,
                                    1 => {
                                        let e = {
                                            let l4 = *ptr1.add(8).cast::<i32>();
                                            super::super::super::wasi::keyvalue::types::IncomingValue::from_handle(
                                                l4 as u32,
                                            )
                                        };
                                        Some(e)
                                    }
                                    _ => _rt::invalid_enum_discriminant(),
                                }
                            };
                            Ok(e)
                        }
                        1 => {
                            let e = {
                                let l5 = *ptr1.add(4).cast::<i32>();
                                super::super::super::wasi::keyvalue::wasi_keyvalue_error::Error::from_handle(
                                    l5 as u32,
                                )
                            };
                            Err(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Set the value associated with the key in the bucket. If the key already
            /// exists in the bucket, it overwrites the value.
            ///
            /// If the key does not exist in the bucket, it creates a new key-value pair.
            ///
            /// If any other error occurs, it returns an `Err(error)`.
            pub fn set(
                bucket: &Bucket,
                key: &Key,
                outgoing_value: &OutgoingValue,
            ) -> Result<(), Error> {
                unsafe {
                    #[repr(align(4))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]);
                    let vec0 = key;
                    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:keyvalue/eventual@0.1.0")]
                    extern "C" {
                        #[link_name = "set"]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: i32, _: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i32, _: *mut u8, _: usize, _: i32, _: *mut u8) {
                        unreachable!()
                    }
                    wit_import(
                        (bucket).handle() as i32,
                        ptr0.cast_mut(),
                        len0,
                        (outgoing_value).handle() as i32,
                        ptr1,
                    );
                    let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                    match l2 {
                        0 => {
                            let e = ();
                            Ok(e)
                        }
                        1 => {
                            let e = {
                                let l3 = *ptr1.add(4).cast::<i32>();
                                super::super::super::wasi::keyvalue::wasi_keyvalue_error::Error::from_handle(
                                    l3 as u32,
                                )
                            };
                            Err(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Delete the key-value pair associated with the key in the bucket.
            ///
            /// If the key does not exist in the bucket, it does nothing.
            ///
            /// If any other error occurs, it returns an `Err(error)`.
            pub fn delete(bucket: &Bucket, key: &Key) -> Result<(), Error> {
                unsafe {
                    #[repr(align(4))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]);
                    let vec0 = key;
                    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:keyvalue/eventual@0.1.0")]
                    extern "C" {
                        #[link_name = "delete"]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8) {
                        unreachable!()
                    }
                    wit_import((bucket).handle() as i32, ptr0.cast_mut(), len0, ptr1);
                    let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                    match l2 {
                        0 => {
                            let e = ();
                            Ok(e)
                        }
                        1 => {
                            let e = {
                                let l3 = *ptr1.add(4).cast::<i32>();
                                super::super::super::wasi::keyvalue::wasi_keyvalue_error::Error::from_handle(
                                    l3 as u32,
                                )
                            };
                            Err(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Check if the key exists in the bucket.
            ///
            /// If the key exists in the bucket, it returns `Ok(true)`. If the key does
            /// not exist in the bucket, it returns `Ok(false)`.
            ///
            /// If any other error occurs, it returns an `Err(error)`.
            pub fn exists(bucket: &Bucket, key: &Key) -> Result<bool, Error> {
                unsafe {
                    #[repr(align(4))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]);
                    let vec0 = key;
                    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:keyvalue/eventual@0.1.0")]
                    extern "C" {
                        #[link_name = "exists"]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8) {
                        unreachable!()
                    }
                    wit_import((bucket).handle() as i32, ptr0.cast_mut(), len0, ptr1);
                    let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                    match l2 {
                        0 => {
                            let e = {
                                let l3 = i32::from(*ptr1.add(4).cast::<u8>());
                                _rt::bool_lift(l3 as u8)
                            };
                            Ok(e)
                        }
                        1 => {
                            let e = {
                                let l4 = *ptr1.add(4).cast::<i32>();
                                super::super::super::wasi::keyvalue::wasi_keyvalue_error::Error::from_handle(
                                    l4 as u32,
                                )
                            };
                            Err(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
        }
    }
    pub mod logging {
        /// WASI Logging is a logging API intended to let users emit log messages with
        /// simple priority levels and context values.
        #[allow(dead_code, clippy::all)]
        pub mod logging {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            /// A log level, describing a kind of message.
            #[repr(u8)]
            #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
            pub enum Level {
                /// Describes messages about the values of variables and the flow of
                /// control within a program.
                Trace,
                /// Describes messages likely to be of interest to someone debugging a
                /// program.
                Debug,
                /// Describes messages likely to be of interest to someone monitoring a
                /// program.
                Info,
                /// Describes messages indicating hazardous situations.
                Warn,
                /// Describes messages indicating serious errors.
                Error,
                /// Describes messages indicating fatal errors.
                Critical,
            }
            impl ::core::fmt::Debug for Level {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        Level::Trace => f.debug_tuple("Level::Trace").finish(),
                        Level::Debug => f.debug_tuple("Level::Debug").finish(),
                        Level::Info => f.debug_tuple("Level::Info").finish(),
                        Level::Warn => f.debug_tuple("Level::Warn").finish(),
                        Level::Error => f.debug_tuple("Level::Error").finish(),
                        Level::Critical => f.debug_tuple("Level::Critical").finish(),
                    }
                }
            }
            impl Level {
                #[doc(hidden)]
                pub unsafe fn _lift(val: u8) -> Level {
                    if !cfg!(debug_assertions) {
                        return ::core::mem::transmute(val);
                    }
                    match val {
                        0 => Level::Trace,
                        1 => Level::Debug,
                        2 => Level::Info,
                        3 => Level::Warn,
                        4 => Level::Error,
                        5 => Level::Critical,
                        _ => panic!("invalid enum discriminant"),
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Emit a log message.
            ///
            /// A log message has a `level` describing what kind of message is being
            /// sent, a context, which is an uninterpreted string meant to help
            /// consumers group similar messages, and a string containing the message
            /// text.
            pub fn log(level: Level, context: &str, message: &str) {
                unsafe {
                    let vec0 = context;
                    let ptr0 = vec0.as_ptr().cast::<u8>();
                    let len0 = vec0.len();
                    let vec1 = message;
                    let ptr1 = vec1.as_ptr().cast::<u8>();
                    let len1 = vec1.len();
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "wasi:logging/logging")]
                    extern "C" {
                        #[link_name = "log"]
                        fn wit_import(
                            _: i32,
                            _: *mut u8,
                            _: usize,
                            _: *mut u8,
                            _: usize,
                        );
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8, _: usize) {
                        unreachable!()
                    }
                    wit_import(
                        level.clone() as i32,
                        ptr0.cast_mut(),
                        len0,
                        ptr1.cast_mut(),
                        len1,
                    );
                }
            }
        }
    }
    pub mod sockets {
        #[allow(dead_code, clippy::all)]
        pub mod network {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            use super::super::super::_rt;
            /// An opaque resource that represents access to (a subset of) the network.
            /// This enables context-based security for networking.
            /// There is no need for this to map 1:1 to a physical network interface.
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct Network {
                handle: _rt::Resource<Network>,
            }
            impl Network {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 Network {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:sockets/network@0.2.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]network"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            /// Error codes.
            ///
            /// In theory, every API can return any error code.
            /// In practice, API's typically only return the errors documented per API
            /// combined with a couple of errors that are always possible:
            /// - `unknown`
            /// - `access-denied`
            /// - `not-supported`
            /// - `out-of-memory`
            /// - `concurrency-conflict`
            ///
            /// See each individual API for what the POSIX equivalents are. They sometimes differ per API.
            #[repr(u8)]
            #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
            pub enum ErrorCode {
                /// Unknown error
                Unknown,
                /// Access denied.
                ///
                /// POSIX equivalent: EACCES, EPERM
                AccessDenied,
                /// The operation is not supported.
                ///
                /// POSIX equivalent: EOPNOTSUPP
                NotSupported,
                /// One of the arguments is invalid.
                ///
                /// POSIX equivalent: EINVAL
                InvalidArgument,
                /// Not enough memory to complete the operation.
                ///
                /// POSIX equivalent: ENOMEM, ENOBUFS, EAI_MEMORY
                OutOfMemory,
                /// The operation timed out before it could finish completely.
                Timeout,
                /// This operation is incompatible with another asynchronous operation that is already in progress.
                ///
                /// POSIX equivalent: EALREADY
                ConcurrencyConflict,
                /// Trying to finish an asynchronous operation that:
                /// - has not been started yet, or:
                /// - was already finished by a previous `finish-*` call.
                ///
                /// Note: this is scheduled to be removed when `future`s are natively supported.
                NotInProgress,
                /// The operation has been aborted because it could not be completed immediately.
                ///
                /// Note: this is scheduled to be removed when `future`s are natively supported.
                WouldBlock,
                /// The operation is not valid in the socket's current state.
                InvalidState,
                /// A new socket resource could not be created because of a system limit.
                NewSocketLimit,
                /// A bind operation failed because the provided address is not an address that the `network` can bind to.
                AddressNotBindable,
                /// A bind operation failed because the provided address is already in use or because there are no ephemeral ports available.
                AddressInUse,
                /// The remote address is not reachable
                RemoteUnreachable,
                /// The TCP connection was forcefully rejected
                ConnectionRefused,
                /// The TCP connection was reset.
                ConnectionReset,
                /// A TCP connection was aborted.
                ConnectionAborted,
                /// The size of a datagram sent to a UDP socket exceeded the maximum
                /// supported size.
                DatagramTooLarge,
                /// Name does not exist or has no suitable associated IP addresses.
                NameUnresolvable,
                /// A temporary failure in name resolution occurred.
                TemporaryResolverFailure,
                /// A permanent failure in name resolution occurred.
                PermanentResolverFailure,
            }
            impl ErrorCode {
                pub fn name(&self) -> &'static str {
                    match self {
                        ErrorCode::Unknown => "unknown",
                        ErrorCode::AccessDenied => "access-denied",
                        ErrorCode::NotSupported => "not-supported",
                        ErrorCode::InvalidArgument => "invalid-argument",
                        ErrorCode::OutOfMemory => "out-of-memory",
                        ErrorCode::Timeout => "timeout",
                        ErrorCode::ConcurrencyConflict => "concurrency-conflict",
                        ErrorCode::NotInProgress => "not-in-progress",
                        ErrorCode::WouldBlock => "would-block",
                        ErrorCode::InvalidState => "invalid-state",
                        ErrorCode::NewSocketLimit => "new-socket-limit",
                        ErrorCode::AddressNotBindable => "address-not-bindable",
                        ErrorCode::AddressInUse => "address-in-use",
                        ErrorCode::RemoteUnreachable => "remote-unreachable",
                        ErrorCode::ConnectionRefused => "connection-refused",
                        ErrorCode::ConnectionReset => "connection-reset",
                        ErrorCode::ConnectionAborted => "connection-aborted",
                        ErrorCode::DatagramTooLarge => "datagram-too-large",
                        ErrorCode::NameUnresolvable => "name-unresolvable",
                        ErrorCode::TemporaryResolverFailure => {
                            "temporary-resolver-failure"
                        }
                        ErrorCode::PermanentResolverFailure => {
                            "permanent-resolver-failure"
                        }
                    }
                }
                pub fn message(&self) -> &'static str {
                    match self {
                        ErrorCode::Unknown => "Unknown error",
                        ErrorCode::AccessDenied => {
                            "Access denied.

                                                                                                                      POSIX equivalent: EACCES, EPERM"
                        }
                        ErrorCode::NotSupported => {
                            "The operation is not supported.

                                                                                                                      POSIX equivalent: EOPNOTSUPP"
                        }
                        ErrorCode::InvalidArgument => {
                            "One of the arguments is invalid.

                                                                                                                      POSIX equivalent: EINVAL"
                        }
                        ErrorCode::OutOfMemory => {
                            "Not enough memory to complete the operation.

                                                                                                                      POSIX equivalent: ENOMEM, ENOBUFS, EAI_MEMORY"
                        }
                        ErrorCode::Timeout => {
                            "The operation timed out before it could finish completely."
                        }
                        ErrorCode::ConcurrencyConflict => {
                            "This operation is incompatible with another asynchronous operation that is already in progress.

                                                                                                                      POSIX equivalent: EALREADY"
                        }
                        ErrorCode::NotInProgress => {
                            "Trying to finish an asynchronous operation that:
                                                                                                                      - has not been started yet, or:
                                                                                                                      - was already finished by a previous `finish-*` call.

                                                                                                                      Note: this is scheduled to be removed when `future`s are natively supported."
                        }
                        ErrorCode::WouldBlock => {
                            "The operation has been aborted because it could not be completed immediately.

                                                                                                                      Note: this is scheduled to be removed when `future`s are natively supported."
                        }
                        ErrorCode::InvalidState => {
                            "The operation is not valid in the socket's current state."
                        }
                        ErrorCode::NewSocketLimit => {
                            "A new socket resource could not be created because of a system limit."
                        }
                        ErrorCode::AddressNotBindable => {
                            "A bind operation failed because the provided address is not an address that the `network` can bind to."
                        }
                        ErrorCode::AddressInUse => {
                            "A bind operation failed because the provided address is already in use or because there are no ephemeral ports available."
                        }
                        ErrorCode::RemoteUnreachable => {
                            "The remote address is not reachable"
                        }
                        ErrorCode::ConnectionRefused => {
                            "The TCP connection was forcefully rejected"
                        }
                        ErrorCode::ConnectionReset => "The TCP connection was reset.",
                        ErrorCode::ConnectionAborted => "A TCP connection was aborted.",
                        ErrorCode::DatagramTooLarge => {
                            "The size of a datagram sent to a UDP socket exceeded the maximum
                                                                                                                      supported size."
                        }
                        ErrorCode::NameUnresolvable => {
                            "Name does not exist or has no suitable associated IP addresses."
                        }
                        ErrorCode::TemporaryResolverFailure => {
                            "A temporary failure in name resolution occurred."
                        }
                        ErrorCode::PermanentResolverFailure => {
                            "A permanent failure in name resolution occurred."
                        }
                    }
                }
            }
            impl ::core::fmt::Debug for ErrorCode {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("ErrorCode")
                        .field("code", &(*self as i32))
                        .field("name", &self.name())
                        .field("message", &self.message())
                        .finish()
                }
            }
            impl ::core::fmt::Display for ErrorCode {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    write!(f, "{} (error {})", self.name(), * self as i32)
                }
            }
            impl std::error::Error for ErrorCode {}
            impl ErrorCode {
                #[doc(hidden)]
                pub unsafe fn _lift(val: u8) -> ErrorCode {
                    if !cfg!(debug_assertions) {
                        return ::core::mem::transmute(val);
                    }
                    match val {
                        0 => ErrorCode::Unknown,
                        1 => ErrorCode::AccessDenied,
                        2 => ErrorCode::NotSupported,
                        3 => ErrorCode::InvalidArgument,
                        4 => ErrorCode::OutOfMemory,
                        5 => ErrorCode::Timeout,
                        6 => ErrorCode::ConcurrencyConflict,
                        7 => ErrorCode::NotInProgress,
                        8 => ErrorCode::WouldBlock,
                        9 => ErrorCode::InvalidState,
                        10 => ErrorCode::NewSocketLimit,
                        11 => ErrorCode::AddressNotBindable,
                        12 => ErrorCode::AddressInUse,
                        13 => ErrorCode::RemoteUnreachable,
                        14 => ErrorCode::ConnectionRefused,
                        15 => ErrorCode::ConnectionReset,
                        16 => ErrorCode::ConnectionAborted,
                        17 => ErrorCode::DatagramTooLarge,
                        18 => ErrorCode::NameUnresolvable,
                        19 => ErrorCode::TemporaryResolverFailure,
                        20 => ErrorCode::PermanentResolverFailure,
                        _ => panic!("invalid enum discriminant"),
                    }
                }
            }
            #[repr(u8)]
            #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
            pub enum IpAddressFamily {
                /// Similar to `AF_INET` in POSIX.
                Ipv4,
                /// Similar to `AF_INET6` in POSIX.
                Ipv6,
            }
            impl ::core::fmt::Debug for IpAddressFamily {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        IpAddressFamily::Ipv4 => {
                            f.debug_tuple("IpAddressFamily::Ipv4").finish()
                        }
                        IpAddressFamily::Ipv6 => {
                            f.debug_tuple("IpAddressFamily::Ipv6").finish()
                        }
                    }
                }
            }
            impl IpAddressFamily {
                #[doc(hidden)]
                pub unsafe fn _lift(val: u8) -> IpAddressFamily {
                    if !cfg!(debug_assertions) {
                        return ::core::mem::transmute(val);
                    }
                    match val {
                        0 => IpAddressFamily::Ipv4,
                        1 => IpAddressFamily::Ipv6,
                        _ => panic!("invalid enum discriminant"),
                    }
                }
            }
            pub type Ipv4Address = (u8, u8, u8, u8);
            pub type Ipv6Address = (u16, u16, u16, u16, u16, u16, u16, u16);
            #[derive(Clone, Copy)]
            pub enum IpAddress {
                Ipv4(Ipv4Address),
                Ipv6(Ipv6Address),
            }
            impl ::core::fmt::Debug for IpAddress {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        IpAddress::Ipv4(e) => {
                            f.debug_tuple("IpAddress::Ipv4").field(e).finish()
                        }
                        IpAddress::Ipv6(e) => {
                            f.debug_tuple("IpAddress::Ipv6").field(e).finish()
                        }
                    }
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct Ipv4SocketAddress {
                /// sin_port
                pub port: u16,
                /// sin_addr
                pub address: Ipv4Address,
            }
            impl ::core::fmt::Debug for Ipv4SocketAddress {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Ipv4SocketAddress")
                        .field("port", &self.port)
                        .field("address", &self.address)
                        .finish()
                }
            }
            #[repr(C)]
            #[derive(Clone, Copy)]
            pub struct Ipv6SocketAddress {
                /// sin6_port
                pub port: u16,
                /// sin6_flowinfo
                pub flow_info: u32,
                /// sin6_addr
                pub address: Ipv6Address,
                /// sin6_scope_id
                pub scope_id: u32,
            }
            impl ::core::fmt::Debug for Ipv6SocketAddress {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    f.debug_struct("Ipv6SocketAddress")
                        .field("port", &self.port)
                        .field("flow-info", &self.flow_info)
                        .field("address", &self.address)
                        .field("scope-id", &self.scope_id)
                        .finish()
                }
            }
            #[derive(Clone, Copy)]
            pub enum IpSocketAddress {
                Ipv4(Ipv4SocketAddress),
                Ipv6(Ipv6SocketAddress),
            }
            impl ::core::fmt::Debug for IpSocketAddress {
                fn fmt(
                    &self,
                    f: &mut ::core::fmt::Formatter<'_>,
                ) -> ::core::fmt::Result {
                    match self {
                        IpSocketAddress::Ipv4(e) => {
                            f.debug_tuple("IpSocketAddress::Ipv4").field(e).finish()
                        }
                        IpSocketAddress::Ipv6(e) => {
                            f.debug_tuple("IpSocketAddress::Ipv6").field(e).finish()
                        }
                    }
                }
            }
        }
        #[allow(dead_code, clippy::all)]
        pub mod ip_name_lookup {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            use super::super::super::_rt;
            pub type Pollable = super::super::super::wasi::io::poll::Pollable;
            pub type Network = super::super::super::wasi::sockets::network::Network;
            pub type ErrorCode = super::super::super::wasi::sockets::network::ErrorCode;
            pub type IpAddress = super::super::super::wasi::sockets::network::IpAddress;
            #[derive(Debug)]
            #[repr(transparent)]
            pub struct ResolveAddressStream {
                handle: _rt::Resource<ResolveAddressStream>,
            }
            impl ResolveAddressStream {
                #[doc(hidden)]
                pub unsafe fn from_handle(handle: u32) -> Self {
                    Self {
                        handle: _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 ResolveAddressStream {
                #[inline]
                unsafe fn drop(_handle: u32) {
                    #[cfg(not(target_arch = "wasm32"))]
                    unreachable!();
                    #[cfg(target_arch = "wasm32")]
                    {
                        #[link(wasm_import_module = "wasi:sockets/ip-name-lookup@0.2.0")]
                        extern "C" {
                            #[link_name = "[resource-drop]resolve-address-stream"]
                            fn drop(_: u32);
                        }
                        drop(_handle);
                    }
                }
            }
            #[allow(unused_unsafe, clippy::all)]
            /// Resolve an internet host name to a list of IP addresses.
            ///
            /// Unicode domain names are automatically converted to ASCII using IDNA encoding.
            /// If the input is an IP address string, the address is parsed and returned
            /// as-is without making any external requests.
            ///
            /// See the wasi-socket proposal README.md for a comparison with getaddrinfo.
            ///
            /// This function never blocks. It either immediately fails or immediately
            /// returns successfully with a `resolve-address-stream` that can be used
            /// to (asynchronously) fetch the results.
            ///
            /// # Typical errors
            /// - `invalid-argument`: `name` is a syntactically invalid domain name or IP address.
            ///
            /// # References:
            /// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getaddrinfo.html>
            /// - <https://man7.org/linux/man-pages/man3/getaddrinfo.3.html>
            /// - <https://learn.microsoft.com/en-us/windows/win32/api/ws2tcpip/nf-ws2tcpip-getaddrinfo>
            /// - <https://man.freebsd.org/cgi/man.cgi?query=getaddrinfo&sektion=3>
            pub fn resolve_addresses(
                network: &Network,
                name: &str,
            ) -> Result<ResolveAddressStream, ErrorCode> {
                unsafe {
                    #[repr(align(4))]
                    struct RetArea([::core::mem::MaybeUninit<u8>; 8]);
                    let mut ret_area = RetArea([::core::mem::MaybeUninit::uninit(); 8]);
                    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:sockets/ip-name-lookup@0.2.0")]
                    extern "C" {
                        #[link_name = "resolve-addresses"]
                        fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8);
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import(_: i32, _: *mut u8, _: usize, _: *mut u8) {
                        unreachable!()
                    }
                    wit_import((network).handle() as i32, ptr0.cast_mut(), len0, ptr1);
                    let l2 = i32::from(*ptr1.add(0).cast::<u8>());
                    match l2 {
                        0 => {
                            let e = {
                                let l3 = *ptr1.add(4).cast::<i32>();
                                ResolveAddressStream::from_handle(l3 as u32)
                            };
                            Ok(e)
                        }
                        1 => {
                            let e = {
                                let l4 = i32::from(*ptr1.add(4).cast::<u8>());
                                super::super::super::wasi::sockets::network::ErrorCode::_lift(
                                    l4 as u8,
                                )
                            };
                            Err(e)
                        }
                        _ => _rt::invalid_enum_discriminant(),
                    }
                }
            }
            impl ResolveAddressStream {
                #[allow(unused_unsafe, clippy::all)]
                /// Returns the next address from the resolver.
                ///
                /// This function should be called multiple times. On each call, it will
                /// return the next address in connection order preference. If all
                /// addresses have been exhausted, this function returns `none`.
                ///
                /// This function never returns IPv4-mapped IPv6 addresses.
                ///
                /// # Typical errors
                /// - `name-unresolvable`:          Name does not exist or has no suitable associated IP addresses. (EAI_NONAME, EAI_NODATA, EAI_ADDRFAMILY)
                /// - `temporary-resolver-failure`: A temporary failure in name resolution occurred. (EAI_AGAIN)
                /// - `permanent-resolver-failure`: A permanent failure in name resolution occurred. (EAI_FAIL)
                /// - `would-block`:                A result is not available yet. (EWOULDBLOCK, EAGAIN)
                pub fn resolve_next_address(
                    &self,
                ) -> Result<Option<IpAddress>, ErrorCode> {
                    unsafe {
                        #[repr(align(2))]
                        struct RetArea([::core::mem::MaybeUninit<u8>; 22]);
                        let mut ret_area = RetArea(
                            [::core::mem::MaybeUninit::uninit(); 22],
                        );
                        let ptr0 = ret_area.0.as_mut_ptr().cast::<u8>();
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:sockets/ip-name-lookup@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]resolve-address-stream.resolve-next-address"]
                            fn wit_import(_: i32, _: *mut u8);
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32, _: *mut u8) {
                            unreachable!()
                        }
                        wit_import((self).handle() as i32, ptr0);
                        let l1 = i32::from(*ptr0.add(0).cast::<u8>());
                        match l1 {
                            0 => {
                                let e = {
                                    let l2 = i32::from(*ptr0.add(2).cast::<u8>());
                                    match l2 {
                                        0 => None,
                                        1 => {
                                            let e = {
                                                let l3 = i32::from(*ptr0.add(4).cast::<u8>());
                                                use super::super::super::wasi::sockets::network::IpAddress as V16;
                                                let v16 = match l3 {
                                                    0 => {
                                                        let e16 = {
                                                            let l4 = i32::from(*ptr0.add(6).cast::<u8>());
                                                            let l5 = i32::from(*ptr0.add(7).cast::<u8>());
                                                            let l6 = i32::from(*ptr0.add(8).cast::<u8>());
                                                            let l7 = i32::from(*ptr0.add(9).cast::<u8>());
                                                            (l4 as u8, l5 as u8, l6 as u8, l7 as u8)
                                                        };
                                                        V16::Ipv4(e16)
                                                    }
                                                    n => {
                                                        debug_assert_eq!(n, 1, "invalid enum discriminant");
                                                        let e16 = {
                                                            let l8 = i32::from(*ptr0.add(6).cast::<u16>());
                                                            let l9 = i32::from(*ptr0.add(8).cast::<u16>());
                                                            let l10 = i32::from(*ptr0.add(10).cast::<u16>());
                                                            let l11 = i32::from(*ptr0.add(12).cast::<u16>());
                                                            let l12 = i32::from(*ptr0.add(14).cast::<u16>());
                                                            let l13 = i32::from(*ptr0.add(16).cast::<u16>());
                                                            let l14 = i32::from(*ptr0.add(18).cast::<u16>());
                                                            let l15 = i32::from(*ptr0.add(20).cast::<u16>());
                                                            (
                                                                l8 as u16,
                                                                l9 as u16,
                                                                l10 as u16,
                                                                l11 as u16,
                                                                l12 as u16,
                                                                l13 as u16,
                                                                l14 as u16,
                                                                l15 as u16,
                                                            )
                                                        };
                                                        V16::Ipv6(e16)
                                                    }
                                                };
                                                v16
                                            };
                                            Some(e)
                                        }
                                        _ => _rt::invalid_enum_discriminant(),
                                    }
                                };
                                Ok(e)
                            }
                            1 => {
                                let e = {
                                    let l17 = i32::from(*ptr0.add(2).cast::<u8>());
                                    super::super::super::wasi::sockets::network::ErrorCode::_lift(
                                        l17 as u8,
                                    )
                                };
                                Err(e)
                            }
                            _ => _rt::invalid_enum_discriminant(),
                        }
                    }
                }
            }
            impl ResolveAddressStream {
                #[allow(unused_unsafe, clippy::all)]
                /// Create a `pollable` which will resolve once the stream is ready for I/O.
                ///
                /// Note: this function is here for WASI Preview2 only.
                /// It's planned to be removed when `future` is natively supported in Preview3.
                pub fn subscribe(&self) -> Pollable {
                    unsafe {
                        #[cfg(target_arch = "wasm32")]
                        #[link(wasm_import_module = "wasi:sockets/ip-name-lookup@0.2.0")]
                        extern "C" {
                            #[link_name = "[method]resolve-address-stream.subscribe"]
                            fn wit_import(_: i32) -> i32;
                        }
                        #[cfg(not(target_arch = "wasm32"))]
                        fn wit_import(_: i32) -> i32 {
                            unreachable!()
                        }
                        let ret = wit_import((self).handle() as i32);
                        super::super::super::wasi::io::poll::Pollable::from_handle(
                            ret as u32,
                        )
                    }
                }
            }
        }
        /// This interface provides a value-export of the default network handle..
        #[allow(dead_code, clippy::all)]
        pub mod instance_network {
            #[used]
            #[doc(hidden)]
            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
            pub type Network = super::super::super::wasi::sockets::network::Network;
            #[allow(unused_unsafe, clippy::all)]
            /// Get a handle to the default network.
            pub fn instance_network() -> Network {
                unsafe {
                    #[cfg(target_arch = "wasm32")]
                    #[link(wasm_import_module = "wasi:sockets/instance-network@0.2.0")]
                    extern "C" {
                        #[link_name = "instance-network"]
                        fn wit_import() -> i32;
                    }
                    #[cfg(not(target_arch = "wasm32"))]
                    fn wit_import() -> i32 {
                        unreachable!()
                    }
                    let ret = wit_import();
                    super::super::super::wasi::sockets::network::Network::from_handle(
                        ret as u32,
                    )
                }
            }
        }
    }
}
#[rustfmt::skip]
mod _rt {
    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 != 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 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 use alloc_crate::vec::Vec;
    pub use alloc_crate::alloc;
    pub use alloc_crate::string::String;
    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
        }
    }
    pub fn as_f32<T: AsF32>(t: T) -> f32 {
        t.as_f32()
    }
    pub trait AsF32 {
        fn as_f32(self) -> f32;
    }
    impl<'a, T: Copy + AsF32> AsF32 for &'a T {
        fn as_f32(self) -> f32 {
            (*self).as_f32()
        }
    }
    impl AsF32 for f32 {
        #[inline]
        fn as_f32(self) -> f32 {
            self as f32
        }
    }
    pub fn as_f64<T: AsF64>(t: T) -> f64 {
        t.as_f64()
    }
    pub trait AsF64 {
        fn as_f64(self) -> f64;
    }
    impl<'a, T: Copy + AsF64> AsF64 for &'a T {
        fn as_f64(self) -> f64 {
            (*self).as_f64()
        }
    }
    impl AsF64 for f64 {
        #[inline]
        fn as_f64(self) -> f64 {
            self as f64
        }
    }
    pub unsafe fn invalid_enum_discriminant<T>() -> T {
        if cfg!(debug_assertions) {
            panic!("invalid enum discriminant")
        } else {
            core::hint::unreachable_unchecked()
        }
    }
    pub unsafe fn cabi_dealloc(ptr: *mut u8, size: usize, align: usize) {
        if size == 0 {
            return;
        }
        let layout = alloc::Layout::from_size_align_unchecked(size, align);
        alloc::dealloc(ptr, layout);
    }
    pub unsafe fn char_lift(val: u32) -> char {
        if cfg!(debug_assertions) {
            core::char::from_u32(val).unwrap()
        } else {
            core::char::from_u32_unchecked(val)
        }
    }
    pub unsafe fn string_lift(bytes: Vec<u8>) -> String {
        if cfg!(debug_assertions) {
            String::from_utf8(bytes).unwrap()
        } else {
            String::from_utf8_unchecked(bytes)
        }
    }
    extern crate alloc as alloc_crate;
}
#[cfg(target_arch = "wasm32")]
#[link_section = "component-type:wit-bindgen:0.36.0:golem:rust:golem-rust:encoded world"]
#[doc(hidden)]
pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 30633] = *b"\
\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\xa7\xee\x01\x01A\x02\
\x01An\x01B\x05\x01r\x02\x07secondsw\x0bnanosecondsy\x04\0\x08datetime\x03\0\0\x01\
@\0\0\x01\x04\0\x03now\x01\x02\x04\0\x0aresolution\x01\x02\x03\0\x1cwasi:clocks/\
wall-clock@0.2.0\x05\0\x01B\x0a\x04\0\x08pollable\x03\x01\x01h\0\x01@\x01\x04sel\
f\x01\0\x7f\x04\0\x16[method]pollable.ready\x01\x02\x01@\x01\x04self\x01\x01\0\x04\
\0\x16[method]pollable.block\x01\x03\x01p\x01\x01py\x01@\x01\x02in\x04\0\x05\x04\
\0\x04poll\x01\x06\x03\0\x12wasi:io/poll@0.2.0\x05\x01\x02\x03\0\0\x08datetime\x02\
\x03\0\x01\x08pollable\x01BK\x02\x03\x02\x01\x02\x04\0\x08datetime\x03\0\0\x02\x03\
\x02\x01\x03\x04\0\x08pollable\x03\0\x02\x01z\x04\0\x0anode-index\x03\0\x04\x01w\
\x04\0\x0bresource-id\x03\0\x06\x01m\x02\x05owned\x08borrowed\x04\0\x0dresource-\
mode\x03\0\x08\x01o\x02s\x05\x01p\x0a\x01k\x05\x01o\x02s\x0c\x01p\x0d\x01ps\x01p\
\x05\x01o\x02\x0c\x0c\x01o\x02\x07\x09\x01q\x16\x0brecord-type\x01\x0b\0\x0cvari\
ant-type\x01\x0e\0\x09enum-type\x01\x0f\0\x0aflags-type\x01\x0f\0\x0atuple-type\x01\
\x10\0\x09list-type\x01\x05\0\x0boption-type\x01\x05\0\x0bresult-type\x01\x11\0\x0c\
prim-u8-type\0\0\x0dprim-u16-type\0\0\x0dprim-u32-type\0\0\x0dprim-u64-type\0\0\x0c\
prim-s8-type\0\0\x0dprim-s16-type\0\0\x0dprim-s32-type\0\0\x0dprim-s64-type\0\0\x0d\
prim-f32-type\0\0\x0dprim-f64-type\0\0\x0eprim-char-type\0\0\x0eprim-bool-type\0\
\0\x10prim-string-type\0\0\x0bhandle-type\x01\x12\0\x04\0\x0dwit-type-node\x03\0\
\x13\x01p\x14\x01r\x01\x05nodes\x15\x04\0\x08wit-type\x03\0\x16\x01r\x01\x05valu\
es\x04\0\x03uri\x03\0\x18\x01o\x02y\x0c\x01p\x7f\x01j\x01\x0c\x01\x0c\x01o\x02\x19\
w\x01q\x16\x0crecord-value\x01\x10\0\x0dvariant-value\x01\x1a\0\x0aenum-value\x01\
y\0\x0bflags-value\x01\x1b\0\x0btuple-value\x01\x10\0\x0alist-value\x01\x10\0\x0c\
option-value\x01\x0c\0\x0cresult-value\x01\x1c\0\x07prim-u8\x01}\0\x08prim-u16\x01\
{\0\x08prim-u32\x01y\0\x08prim-u64\x01w\0\x07prim-s8\x01~\0\x08prim-s16\x01|\0\x08\
prim-s32\x01z\0\x08prim-s64\x01x\0\x0cprim-float32\x01v\0\x0cprim-float64\x01u\0\
\x09prim-char\x01t\0\x09prim-bool\x01\x7f\0\x0bprim-string\x01s\0\x06handle\x01\x1d\
\0\x04\0\x08wit-node\x03\0\x1e\x01p\x1f\x01r\x01\x05nodes\x20\x04\0\x09wit-value\
\x03\0!\x01r\x02\x05value\"\x03typ\x17\x04\0\x0evalue-and-type\x03\0#\x01q\x04\x0e\
protocol-error\x01s\0\x06denied\x01s\0\x09not-found\x01s\0\x15remote-internal-er\
ror\x01s\0\x04\0\x09rpc-error\x03\0%\x04\0\x08wasm-rpc\x03\x01\x04\0\x14future-i\
nvoke-result\x03\x01\x04\0\x12cancellation-token\x03\x01\x01i'\x01@\x01\x08locat\
ion\x19\0*\x04\0\x15[constructor]wasm-rpc\x01+\x01h'\x01p\"\x01j\x01\"\x01&\x01@\
\x03\x04self,\x0dfunction-names\x0ffunction-params-\0.\x04\0![method]wasm-rpc.in\
voke-and-await\x01/\x01j\0\x01&\x01@\x03\x04self,\x0dfunction-names\x0ffunction-\
params-\00\x04\0\x17[method]wasm-rpc.invoke\x011\x01i(\x01@\x03\x04self,\x0dfunc\
tion-names\x0ffunction-params-\02\x04\0'[method]wasm-rpc.async-invoke-and-await\x01\
3\x01@\x04\x04self,\x0escheduled-time\x01\x0dfunction-names\x0ffunction-params-\x01\
\0\x04\0$[method]wasm-rpc.schedule-invocation\x014\x01i)\x01@\x04\x04self,\x0esc\
heduled-time\x01\x0dfunction-names\x0ffunction-params-\05\x04\0/[method]wasm-rpc\
.schedule-cancelable-invocation\x016\x01h(\x01i\x03\x01@\x01\x04self7\08\x04\0&[\
method]future-invoke-result.subscribe\x019\x01k.\x01@\x01\x04self7\0:\x04\0\x20[\
method]future-invoke-result.get\x01;\x01h)\x01@\x01\x04self<\x01\0\x04\0![method\
]cancellation-token.cancel\x01=\x01@\x01\x03vnt$\0\"\x04\0\x0dextract-value\x01>\
\x01@\x01\x03vnt$\0\x17\x04\0\x0cextract-type\x01?\x03\0\x15golem:rpc/types@0.1.\
3\x05\x04\x01B\x0f\x02\x03\x02\x01\x03\x04\0\x08pollable\x03\0\0\x01w\x04\0\x07i\
nstant\x03\0\x02\x01w\x04\0\x08duration\x03\0\x04\x01@\0\0\x03\x04\0\x03now\x01\x06\
\x01@\0\0\x05\x04\0\x0aresolution\x01\x07\x01i\x01\x01@\x01\x04when\x03\0\x08\x04\
\0\x11subscribe-instant\x01\x09\x01@\x01\x04when\x05\0\x08\x04\0\x12subscribe-du\
ration\x01\x0a\x03\0!wasi:clocks/monotonic-clock@0.2.0\x05\x05\x02\x03\0\x02\x03\
uri\x02\x03\0\x02\x09wit-value\x02\x03\0\x03\x08duration\x01B{\x02\x03\x02\x01\x06\
\x04\0\x03uri\x03\0\0\x02\x03\x02\x01\x07\x04\0\x09wit-value\x03\0\x02\x02\x03\x02\
\x01\x08\x04\0\x08duration\x03\0\x04\x01w\x04\0\x0boplog-index\x03\0\x06\x01w\x04\
\0\x11component-version\x03\0\x08\x01r\x02\x09high-bitsw\x08low-bitsw\x04\0\x04u\
uid\x03\0\x0a\x01r\x01\x04uuid\x0b\x04\0\x0ccomponent-id\x03\0\x0c\x01r\x02\x0cc\
omponent-id\x0d\x0bworker-names\x04\0\x09worker-id\x03\0\x0e\x01r\x02\x09worker-\
id\x0f\x09oplog-idx\x07\x04\0\x0apromise-id\x03\0\x10\x01r\x01\x05values\x04\0\x0a\
account-id\x03\0\x12\x01ku\x01r\x05\x0cmax-attemptsy\x09min-delay\x05\x09max-del\
ay\x05\x0amultiplieru\x11max-jitter-factor\x14\x04\0\x0cretry-policy\x03\0\x15\x01\
q\x03\x0fpersist-nothing\0\0\x1bpersist-remote-side-effects\0\0\x05smart\0\0\x04\
\0\x11persistence-level\x03\0\x17\x01m\x02\x09automatic\x0esnapshot-based\x04\0\x0b\
update-mode\x03\0\x19\x01m\x06\x05equal\x09not-equal\x0dgreater-equal\x07greater\
\x0aless-equal\x04less\x04\0\x11filter-comparator\x03\0\x1b\x01m\x04\x05equal\x09\
not-equal\x04like\x08not-like\x04\0\x18string-filter-comparator\x03\0\x1d\x01m\x07\
\x07running\x04idle\x09suspended\x0binterrupted\x08retrying\x06failed\x06exited\x04\
\0\x0dworker-status\x03\0\x1f\x01r\x02\x0acomparator\x1e\x05values\x04\0\x12work\
er-name-filter\x03\0!\x01r\x02\x0acomparator\x1c\x05value\x20\x04\0\x14worker-st\
atus-filter\x03\0#\x01r\x02\x0acomparator\x1c\x05valuew\x04\0\x15worker-version-\
filter\x03\0%\x01r\x02\x0acomparator\x1c\x05valuew\x04\0\x18worker-created-at-fi\
lter\x03\0'\x01r\x03\x04names\x0acomparator\x1e\x05values\x04\0\x11worker-env-fi\
lter\x03\0)\x01q\x05\x04name\x01\"\0\x06status\x01$\0\x07version\x01&\0\x0acreat\
ed-at\x01(\0\x03env\x01*\0\x04\0\x16worker-property-filter\x03\0+\x01p,\x01r\x01\
\x07filters-\x04\0\x11worker-all-filter\x03\0.\x01p/\x01r\x01\x07filters0\x04\0\x11\
worker-any-filter\x03\01\x01ps\x01o\x02ss\x01p4\x01r\x06\x09worker-id\x0f\x04arg\
s3\x03env5\x06status\x20\x11component-versionw\x0bretry-countw\x04\0\x0fworker-m\
etadata\x03\06\x04\0\x0bget-workers\x03\x01\x01q\x02\x15revert-to-oplog-index\x01\
\x07\0\x17revert-last-invocations\x01w\0\x04\0\x14revert-worker-target\x03\09\x01\
k2\x01i8\x01@\x03\x0ccomponent-id\x0d\x06filter;\x07precise\x7f\0<\x04\0\x18[con\
structor]get-workers\x01=\x01h8\x01p7\x01k?\x01@\x01\x04self>\0\xc0\0\x04\0\x1c[\
method]get-workers.get-next\x01A\x01@\0\0\x11\x04\0\x0ecreate-promise\x01B\x01p}\
\x01@\x01\x0apromise-id\x11\0\xc3\0\x04\0\x0dawait-promise\x01D\x01k\xc3\0\x01@\x01\
\x0apromise-id\x11\0\xc5\0\x04\0\x0cpoll-promise\x01F\x01@\x02\x0apromise-id\x11\
\x04data\xc3\0\0\x7f\x04\0\x10complete-promise\x01G\x01@\x01\x0apromise-id\x11\x01\
\0\x04\0\x0edelete-promise\x01H\x01@\0\0\x07\x04\0\x0fget-oplog-index\x01I\x01@\x01\
\x09oplog-idx\x07\x01\0\x04\0\x0fset-oplog-index\x01J\x01@\x01\x08replicas}\x01\0\
\x04\0\x0coplog-commit\x01K\x04\0\x14mark-begin-operation\x01I\x01@\x01\x05begin\
\x07\x01\0\x04\0\x12mark-end-operation\x01L\x01@\0\0\x16\x04\0\x10get-retry-poli\
cy\x01M\x01@\x01\x10new-retry-policy\x16\x01\0\x04\0\x10set-retry-policy\x01N\x01\
@\0\0\x18\x04\0\x1bget-oplog-persistence-level\x01O\x01@\x01\x15new-persistence-\
level\x18\x01\0\x04\0\x1bset-oplog-persistence-level\x01P\x01@\0\0\x7f\x04\0\x14\
get-idempotence-mode\x01Q\x01@\x01\x0aidempotent\x7f\x01\0\x04\0\x14set-idempote\
nce-mode\x01R\x01@\0\0\x0b\x04\0\x18generate-idempotency-key\x01S\x01@\x03\x09wo\
rker-id\x0f\x0etarget-version\x09\x04mode\x1a\x01\0\x04\0\x0dupdate-worker\x01T\x01\
@\0\07\x04\0\x11get-self-metadata\x01U\x01k7\x01@\x01\x09worker-id\x0f\0\xd6\0\x04\
\0\x13get-worker-metadata\x01W\x01@\x03\x10source-worker-id\x0f\x10target-worker\
-id\x0f\x11oplog-idx-cut-off\x07\x01\0\x04\0\x0bfork-worker\x01X\x01@\x02\x09wor\
ker-id\x0f\x0drevert-target:\x01\0\x04\0\x0drevert-worker\x01Y\x01k\x0d\x01@\x01\
\x13component-references\0\xda\0\x04\0\x14resolve-component-id\x01[\x01k\x0f\x01\
@\x02\x13component-references\x0bworker-names\0\xdc\0\x04\0\x11resolve-worker-id\
\x01]\x04\0\x18resolve-worker-id-strict\x01]\x01@\x01\x09worker-id\x0f\0\x01\x04\
\0\x0aworker-uri\x01^\x03\0\x14golem:api/host@1.1.5\x05\x09\x01B7\x02\x03\x02\x01\
\x02\x04\0\x08datetime\x03\0\0\x04\0\x04span\x03\x01\x04\0\x12invocation-context\
\x03\x01\x01q\x01\x06string\x01s\0\x04\0\x0fattribute-value\x03\0\x04\x01r\x02\x03\
keys\x05value\x05\x04\0\x09attribute\x03\0\x06\x01p\x05\x01r\x02\x03keys\x06valu\
es\x08\x04\0\x0fattribute-chain\x03\0\x09\x01s\x04\0\x08trace-id\x03\0\x0b\x01s\x04\
\0\x07span-id\x03\0\x0d\x01h\x02\x01@\x01\x04self\x0f\0\x01\x04\0\x17[method]spa\
n.started-at\x01\x10\x01@\x03\x04self\x0f\x04names\x05value\x05\x01\0\x04\0\x1a[\
method]span.set-attribute\x01\x11\x01p\x07\x01@\x02\x04self\x0f\x0aattributes\x12\
\x01\0\x04\0\x1b[method]span.set-attributes\x01\x13\x01@\x01\x04self\x0f\x01\0\x04\
\0\x13[method]span.finish\x01\x14\x01h\x03\x01@\x01\x04self\x15\0\x0c\x04\0#[met\
hod]invocation-context.trace-id\x01\x16\x01@\x01\x04self\x15\0\x0e\x04\0\"[metho\
d]invocation-context.span-id\x01\x17\x01i\x03\x01k\x18\x01@\x01\x04self\x15\0\x19\
\x04\0![method]invocation-context.parent\x01\x1a\x01k\x05\x01@\x03\x04self\x15\x03\
keys\x09inherited\x7f\0\x1b\x04\0([method]invocation-context.get-attribute\x01\x1c\
\x01@\x02\x04self\x15\x09inherited\x7f\0\x12\x04\0)[method]invocation-context.ge\
t-attributes\x01\x1d\x01@\x02\x04self\x15\x03keys\0\x08\x04\0.[method]invocation\
-context.get-attribute-chain\x01\x1e\x01p\x0a\x01@\x01\x04self\x15\0\x1f\x04\0/[\
method]invocation-context.get-attribute-chains\x01\x20\x01o\x02ss\x01p!\x01@\x01\
\x04self\x15\0\"\x04\00[method]invocation-context.trace-context-headers\x01#\x01\
i\x02\x01@\x01\x04names\0$\x04\0\x0astart-span\x01%\x01@\0\0\x18\x04\0\x0fcurren\
t-context\x01&\x01@\x01\x05allow\x7f\0\x7f\x04\0&allow-forwarding-trace-context-\
headers\x01'\x03\0\x17golem:api/context@1.1.5\x05\x0a\x02\x03\0\x04\x0aaccount-i\
d\x02\x03\0\x04\x11component-version\x02\x03\0\x04\x0boplog-index\x02\x03\0\x04\x0c\
retry-policy\x02\x03\0\x04\x04uuid\x02\x03\0\x04\x09worker-id\x02\x03\0\x05\x09a\
ttribute\x02\x03\0\x05\x0fattribute-value\x02\x03\0\x05\x07span-id\x02\x03\0\x05\
\x08trace-id\x01B\x82\x01\x02\x03\x02\x01\x02\x04\0\x08datetime\x03\0\0\x02\x03\x02\
\x01\x07\x04\0\x09wit-value\x03\0\x02\x02\x03\x02\x01\x0b\x04\0\x0aaccount-id\x03\
\0\x04\x02\x03\x02\x01\x0c\x04\0\x11component-version\x03\0\x06\x02\x03\x02\x01\x0d\
\x04\0\x0boplog-index\x03\0\x08\x02\x03\x02\x01\x0e\x04\0\x0cretry-policy\x03\0\x0a\
\x02\x03\x02\x01\x0f\x04\0\x04uuid\x03\0\x0c\x02\x03\x02\x01\x10\x04\0\x09worker\
-id\x03\0\x0e\x02\x03\x02\x01\x11\x04\0\x09attribute\x03\0\x10\x02\x03\x02\x01\x12\
\x04\0\x0fattribute-value\x03\0\x12\x02\x03\x02\x01\x13\x04\0\x07span-id\x03\0\x14\
\x02\x03\x02\x01\x14\x04\0\x08trace-id\x03\0\x16\x01k\x09\x01q\x05\x0aread-local\
\0\0\x0bwrite-local\0\0\x0bread-remote\0\0\x0cwrite-remote\0\0\x14write-remote-b\
atched\x01\x18\0\x04\0\x15wrapped-function-type\x03\0\x19\x01o\x02ss\x01p\x1b\x01\
r\x04\x0finstallation-id\x0d\x04names\x07versions\x0aparameters\x1c\x04\0\x1fplu\
gin-installation-description\x03\0\x1d\x01ps\x01k\x0f\x01p\x1e\x01r\x0a\x09times\
tamp\x01\x09worker-id\x0f\x11component-version\x07\x04args\x1f\x03env\x1c\x0aacc\
ount-id\x05\x06parent\x20\x0ecomponent-sizew\x20initial-total-linear-memory-size\
w\x16initial-active-plugins!\x04\0\x11create-parameters\x03\0\"\x01r\x05\x09time\
stamp\x01\x0dfunction-names\x07request\x03\x08response\x03\x15wrapped-function-t\
ype\x1a\x04\0$imported-function-invoked-parameters\x03\0$\x01k\x15\x01kw\x01p\x11\
\x01r\x06\x07span-id\x15\x05start\x01\x06parent&\x0elinked-context'\x0aattribute\
s(\x09inherited\x7f\x04\0\x0flocal-span-data\x03\0)\x01r\x01\x07span-id\x15\x04\0\
\x12external-span-data\x03\0+\x01q\x02\x0alocal-span\x01*\0\x0dexternal-span\x01\
,\0\x04\0\x09span-data\x03\0-\x01p\x03\x01p.\x01p0\x01r\x07\x09timestamp\x01\x0d\
function-names\x07request/\x0fidempotency-keys\x08trace-id\x17\x0ctrace-states\x1f\
\x12invocation-context1\x04\0$exported-function-invoked-parameters\x03\02\x01r\x03\
\x09timestamp\x01\x08response\x03\x0dconsumed-fuelx\x04\0&exported-function-comp\
leted-parameters\x03\04\x01r\x02\x09timestamp\x01\x05errors\x04\0\x10error-param\
eters\x03\06\x01r\x03\x09timestamp\x01\x05start\x09\x03end\x09\x04\0\x0fjump-par\
ameters\x03\08\x01r\x02\x09timestamp\x01\x0cretry-policy\x0b\x04\0\x1echange-ret\
ry-policy-parameters\x03\0:\x01r\x02\x09timestamp\x01\x0bbegin-index\x09\x04\0\x1c\
end-atomic-region-parameters\x03\0<\x01r\x02\x09timestamp\x01\x0bbegin-index\x09\
\x04\0\x1bend-remote-write-parameters\x03\0>\x01k/\x01r\x03\x0fidempotency-keys\x0d\
function-names\x05input\xc0\0\x04\0'exported-function-invocation-parameters\x03\0\
A\x01q\x02\x11exported-function\x01\xc2\0\0\x0dmanual-update\x01\x07\0\x04\0\x11\
worker-invocation\x03\0C\x01r\x02\x09timestamp\x01\x0ainvocation\xc4\0\x04\0$pen\
ding-worker-invocation-parameters\x03\0E\x01p}\x01q\x02\x0bauto-update\0\0\x0esn\
apshot-based\x01\xc7\0\0\x04\0\x12update-description\x03\0H\x01r\x03\x09timestam\
p\x01\x0etarget-version\x07\x12update-description\xc9\0\x04\0\x19pending-update-\
parameters\x03\0J\x01r\x04\x09timestamp\x01\x0etarget-version\x07\x12new-compone\
nt-sizew\x12new-active-plugins!\x04\0\x1csuccessful-update-parameters\x03\0L\x01\
ks\x01r\x03\x09timestamp\x01\x0etarget-version\x07\x07details\xce\0\x04\0\x18fai\
led-update-parameters\x03\0O\x01r\x02\x09timestamp\x01\x05deltaw\x04\0\x16grow-m\
emory-parameters\x03\0Q\x01w\x04\0\x12worker-resource-id\x03\0S\x01r\x02\x09time\
stamp\x01\x0bresource-id\xd4\0\x04\0\x1acreate-resource-parameters\x03\0U\x01r\x02\
\x09timestamp\x01\x0bresource-id\xd4\0\x04\0\x18drop-resource-parameters\x03\0W\x01\
r\x04\x09timestamp\x01\x0bresource-id\xd4\0\x0dresource-names\x0fresource-params\
/\x04\0\x1cdescribe-resource-parameters\x03\0Y\x01m\x08\x06stdout\x06stderr\x05t\
race\x05debug\x04info\x04warn\x05error\x08critical\x04\0\x09log-level\x03\0[\x01\
r\x04\x09timestamp\x01\x05level\xdc\0\x07contexts\x07messages\x04\0\x0elog-param\
eters\x03\0]\x01r\x02\x09timestamp\x01\x06plugin\x1e\x04\0\x1aactivate-plugin-pa\
rameters\x03\0_\x01r\x02\x09timestamp\x01\x06plugin\x1e\x04\0\x1cdeactivate-plug\
in-parameters\x03\0a\x01r\x03\x09timestamp\x01\x05start\x09\x03end\x09\x04\0\x11\
revert-parameters\x03\0c\x01r\x02\x09timestamp\x01\x0fidempotency-keys\x04\0\x1c\
cancel-invocation-parameters\x03\0e\x01r\x05\x09timestamp\x01\x07span-id\x15\x06\
parent&\x0elinked-context&\x0aattributes(\x04\0\x15start-span-parameters\x03\0g\x01\
r\x02\x09timestamp\x01\x07span-id\x15\x04\0\x16finish-span-parameters\x03\0i\x01\
r\x04\x09timestamp\x01\x07span-id\x15\x03keys\x05value\x13\x04\0\x1dset-span-att\
ribute-parameters\x03\0k\x01q\x20\x06create\x01#\0\x19imported-function-invoked\x01\
%\0\x19exported-function-invoked\x013\0\x1bexported-function-completed\x015\0\x07\
suspend\x01\x01\0\x05error\x017\0\x05no-op\x01\x01\0\x04jump\x019\0\x0binterrupt\
ed\x01\x01\0\x06exited\x01\x01\0\x13change-retry-policy\x01;\0\x13begin-atomic-r\
egion\x01\x01\0\x11end-atomic-region\x01=\0\x12begin-remote-write\x01\x01\0\x10e\
nd-remote-write\x01?\0\x19pending-worker-invocation\x01\xc6\0\0\x0epending-updat\
e\x01\xcb\0\0\x11successful-update\x01\xcd\0\0\x0dfailed-update\x01\xd0\0\0\x0bg\
row-memory\x01\xd2\0\0\x0fcreate-resource\x01\xd6\0\0\x0ddrop-resource\x01\xd8\0\
\0\x11describe-resource\x01\xda\0\0\x03log\x01\xde\0\0\x07restart\x01\x01\0\x0fa\
ctivate-plugin\x01\xe0\0\0\x11deactivate-plugin\x01\xe2\0\0\x06revert\x01\xe4\0\0\
\x11cancel-invocation\x01\xe6\0\0\x0astart-span\x01\xe8\0\0\x0bfinish-span\x01\xea\
\0\0\x12set-span-attribute\x01\xec\0\0\x04\0\x0boplog-entry\x03\0m\x04\0\x09get-\
oplog\x03\x01\x04\0\x0csearch-oplog\x03\x01\x01io\x01@\x02\x09worker-id\x0f\x05s\
tart\x09\0\xf1\0\x04\0\x16[constructor]get-oplog\x01r\x01ho\x01p\xee\0\x01k\xf4\0\
\x01@\x01\x04self\xf3\0\0\xf5\0\x04\0\x1a[method]get-oplog.get-next\x01v\x01ip\x01\
@\x02\x09worker-id\x0f\x04texts\0\xf7\0\x04\0\x19[constructor]search-oplog\x01x\x01\
hp\x01o\x02\x09\xee\0\x01p\xfa\0\x01k\xfb\0\x01@\x01\x04self\xf9\0\0\xfc\0\x04\0\
\x1d[method]search-oplog.get-next\x01}\x03\0\x15golem:api/oplog@1.1.5\x05\x15\x02\
\x03\0\x04\x11persistence-level\x02\x03\0\x06\x0boplog-index\x02\x03\0\x06\x15wr\
apped-function-type\x02\x03\0\x02\x0evalue-and-type\x01B\x20\x02\x03\x02\x01\x16\
\x04\0\x11persistence-level\x03\0\0\x02\x03\x02\x01\x17\x04\0\x0boplog-index\x03\
\0\x02\x02\x03\x02\x01\x18\x04\0\x15wrapped-function-type\x03\0\x04\x02\x03\x02\x01\
\x02\x04\0\x08datetime\x03\0\x06\x02\x03\x02\x01\x19\x04\0\x0evalue-and-type\x03\
\0\x08\x04\0\x15durable-function-type\x03\0\x05\x01r\x02\x07is-live\x7f\x11persi\
stence-level\x01\x04\0\x17durable-execution-state\x03\0\x0b\x01m\x02\x02v1\x02v2\
\x04\0\x13oplog-entry-version\x03\0\x0d\x01p}\x01r\x05\x09timestamp\x07\x0dfunct\
ion-names\x08response\x0f\x0dfunction-type\x0a\x0dentry-version\x0e\x04\0%persis\
ted-durable-function-invocation\x03\0\x10\x01@\x02\x05ifaces\x08functions\x01\0\x04\
\0\x15observe-function-call\x01\x12\x01@\x01\x0dfunction-type\x0a\0\x03\x04\0\x16\
begin-durable-function\x01\x13\x01@\x03\x0dfunction-type\x0a\x0bbegin-index\x03\x0d\
forced-commit\x7f\x01\0\x04\0\x14end-durable-function\x01\x14\x01@\0\0\x0c\x04\0\
\x1fcurrent-durable-execution-state\x01\x15\x01@\x04\x0dfunction-names\x07reques\
t\x0f\x08response\x0f\x0dfunction-type\x0a\x01\0\x04\0#persist-durable-function-\
invocation\x01\x16\x01@\x04\x0dfunction-names\x07request\x09\x08response\x09\x0d\
function-type\x0a\x01\0\x04\0)persist-typed-durable-function-invocation\x01\x17\x01\
@\0\0\x11\x04\0*read-persisted-durable-function-invocation\x01\x18\x03\0!golem:d\
urability/durability@1.2.0\x05\x1a\x01B\x13\x01r\x02\x09high-bitsw\x08low-bitsw\x04\
\0\x04uuid\x03\0\0\x01o\x04}}}}\x01o\x08{{{{{{{{\x01q\x02\x04ipv4\x01\x02\0\x04i\
pv6\x01\x03\0\x04\0\x0aip-address\x03\0\x04\x01o\x06}}}}}}\x01r\x01\x06octets\x06\
\x04\0\x0bmac-address\x03\0\x07\x01r\x03\x04yearz\x05month}\x03day}\x04\0\x04dat\
e\x03\0\x09\x01r\x04\x04hour}\x06minute}\x06second}\x0ananosecondy\x04\0\x04time\
\x03\0\x0b\x01r\x02\x04date\x0a\x04time\x0c\x04\0\x09timestamp\x03\0\x0d\x01r\x02\
\x09timestamp\x0e\x06offsetz\x04\0\x0btimestamptz\x03\0\x0f\x01r\x02\x04time\x0c\
\x06offsetz\x04\0\x06timetz\x03\0\x11\x03\0\x17golem:rdbms/types@0.0.1\x05\x1b\x02\
\x03\0\x08\x04date\x02\x03\0\x08\x04time\x02\x03\0\x08\x09timestamp\x01B>\x02\x03\
\x02\x01\x1c\x04\0\x04date\x03\0\0\x02\x03\x02\x01\x1d\x04\0\x04time\x03\0\x02\x02\
\x03\x02\x01\x1e\x04\0\x09timestamp\x03\0\x04\x01q\x05\x12connection-failure\x01\
s\0\x17query-parameter-failure\x01s\0\x17query-execution-failure\x01s\0\x16query\
-response-failure\x01s\0\x05other\x01s\0\x04\0\x05error\x03\0\x06\x01q#\x07boole\
an\0\0\x07tinyint\0\0\x08smallint\0\0\x09mediumint\0\0\x03int\0\0\x06bigint\0\0\x10\
tinyint-unsigned\0\0\x11smallint-unsigned\0\0\x12mediumint-unsigned\0\0\x0cint-u\
nsigned\0\0\x0fbigint-unsigned\0\0\x05float\0\0\x06double\0\0\x07decimal\0\0\x04\
date\0\0\x08datetime\0\0\x09timestamp\0\0\x04time\0\0\x04year\0\0\x07fixchar\0\0\
\x07varchar\0\0\x08tinytext\0\0\x04text\0\0\x0amediumtext\0\0\x08longtext\0\0\x06\
binary\0\0\x09varbinary\0\0\x08tinyblob\0\0\x04blob\0\0\x0amediumblob\0\0\x08lon\
gblob\0\0\x0benumeration\0\0\x03set\0\0\x03bit\0\0\x04json\0\0\x04\0\x0edb-colum\
n-type\x03\0\x08\x01r\x04\x07ordinalw\x04names\x07db-type\x09\x0cdb-type-names\x04\
\0\x09db-column\x03\0\x0a\x01p}\x01p\x7f\x01q$\x07boolean\x01\x7f\0\x07tinyint\x01\
~\0\x08smallint\x01|\0\x09mediumint\x01z\0\x03int\x01z\0\x06bigint\x01x\0\x10tin\
yint-unsigned\x01}\0\x11smallint-unsigned\x01{\0\x12mediumint-unsigned\x01y\0\x0c\
int-unsigned\x01y\0\x0fbigint-unsigned\x01w\0\x05float\x01v\0\x06double\x01u\0\x07\
decimal\x01s\0\x04date\x01\x01\0\x08datetime\x01\x05\0\x09timestamp\x01\x05\0\x04\
time\x01\x03\0\x04year\x01{\0\x07fixchar\x01s\0\x07varchar\x01s\0\x08tinytext\x01\
s\0\x04text\x01s\0\x0amediumtext\x01s\0\x08longtext\x01s\0\x06binary\x01\x0c\0\x09\
varbinary\x01\x0c\0\x08tinyblob\x01\x0c\0\x04blob\x01\x0c\0\x0amediumblob\x01\x0c\
\0\x08longblob\x01\x0c\0\x0benumeration\x01s\0\x03set\x01s\0\x03bit\x01\x0d\0\x04\
json\x01s\0\x04null\0\0\x04\0\x08db-value\x03\0\x0e\x01p\x0f\x01r\x01\x06values\x10\
\x04\0\x06db-row\x03\0\x11\x01p\x0b\x01p\x12\x01r\x02\x07columns\x13\x04rows\x14\
\x04\0\x09db-result\x03\0\x15\x04\0\x10db-result-stream\x03\x01\x04\0\x0ddb-conn\
ection\x03\x01\x04\0\x0edb-transaction\x03\x01\x01h\x17\x01@\x01\x04self\x1a\0\x13\
\x04\0$[method]db-result-stream.get-columns\x01\x1b\x01k\x14\x01@\x01\x04self\x1a\
\0\x1c\x04\0![method]db-result-stream.get-next\x01\x1d\x01i\x18\x01j\x01\x1e\x01\
\x07\x01@\x01\x07addresss\0\x1f\x04\0\x1a[static]db-connection.open\x01\x20\x01h\
\x18\x01j\x01\x16\x01\x07\x01@\x03\x04self!\x09statements\x06params\x10\0\"\x04\0\
\x1b[method]db-connection.query\x01#\x01i\x17\x01j\x01$\x01\x07\x01@\x03\x04self\
!\x09statements\x06params\x10\0%\x04\0\"[method]db-connection.query-stream\x01&\x01\
j\x01w\x01\x07\x01@\x03\x04self!\x09statements\x06params\x10\0'\x04\0\x1d[method\
]db-connection.execute\x01(\x01i\x19\x01j\x01)\x01\x07\x01@\x01\x04self!\0*\x04\0\
'[method]db-connection.begin-transaction\x01+\x01h\x19\x01@\x03\x04self,\x09stat\
ements\x06params\x10\0\"\x04\0\x1c[method]db-transaction.query\x01-\x01@\x03\x04\
self,\x09statements\x06params\x10\0%\x04\0#[method]db-transaction.query-stream\x01\
.\x01@\x03\x04self,\x09statements\x06params\x10\0'\x04\0\x1e[method]db-transacti\
on.execute\x01/\x01j\0\x01\x07\x01@\x01\x04self,\00\x04\0\x1d[method]db-transact\
ion.commit\x011\x04\0\x1f[method]db-transaction.rollback\x011\x03\0\x17golem:rdb\
ms/mysql@0.0.1\x05\x1f\x02\x03\0\x08\x06timetz\x02\x03\0\x08\x0btimestamptz\x02\x03\
\0\x08\x04uuid\x02\x03\0\x08\x0aip-address\x02\x03\0\x08\x0bmac-address\x01B\x87\
\x01\x02\x03\x02\x01\x1c\x04\0\x04date\x03\0\0\x02\x03\x02\x01\x1d\x04\0\x04time\
\x03\0\x02\x02\x03\x02\x01\x20\x04\0\x06timetz\x03\0\x04\x02\x03\x02\x01\x1e\x04\
\0\x09timestamp\x03\0\x06\x02\x03\x02\x01!\x04\0\x0btimestamptz\x03\0\x08\x02\x03\
\x02\x01\"\x04\0\x04uuid\x03\0\x0a\x02\x03\x02\x01#\x04\0\x0aip-address\x03\0\x0c\
\x02\x03\x02\x01$\x04\0\x0bmac-address\x03\0\x0e\x01q\x05\x12connection-failure\x01\
s\0\x17query-parameter-failure\x01s\0\x17query-execution-failure\x01s\0\x16query\
-response-failure\x01s\0\x05other\x01s\0\x04\0\x05error\x03\0\x10\x01r\x03\x06mo\
nthsz\x04daysz\x0cmicrosecondsx\x04\0\x08interval\x03\0\x12\x01q\x03\x08included\
\x01z\0\x08excluded\x01z\0\x09unbounded\0\0\x04\0\x09int4bound\x03\0\x14\x01q\x03\
\x08included\x01x\0\x08excluded\x01x\0\x09unbounded\0\0\x04\0\x09int8bound\x03\0\
\x16\x01q\x03\x08included\x01s\0\x08excluded\x01s\0\x09unbounded\0\0\x04\0\x08nu\
mbound\x03\0\x18\x01q\x03\x08included\x01\x07\0\x08excluded\x01\x07\0\x09unbound\
ed\0\0\x04\0\x07tsbound\x03\0\x1a\x01q\x03\x08included\x01\x09\0\x08excluded\x01\
\x09\0\x09unbounded\0\0\x04\0\x09tstzbound\x03\0\x1c\x01q\x03\x08included\x01\x01\
\0\x08excluded\x01\x01\0\x09unbounded\0\0\x04\0\x09datebound\x03\0\x1e\x01r\x02\x05\
start\x15\x03end\x15\x04\0\x09int4range\x03\0\x20\x01r\x02\x05start\x17\x03end\x17\
\x04\0\x09int8range\x03\0\"\x01r\x02\x05start\x19\x03end\x19\x04\0\x08numrange\x03\
\0$\x01r\x02\x05start\x1b\x03end\x1b\x04\0\x07tsrange\x03\0&\x01r\x02\x05start\x1d\
\x03end\x1d\x04\0\x09tstzrange\x03\0(\x01r\x02\x05start\x1f\x03end\x1f\x04\0\x09\
daterange\x03\0*\x01r\x01\x04names\x04\0\x10enumeration-type\x03\0,\x01r\x02\x04\
names\x05values\x04\0\x0benumeration\x03\0.\x04\0\x0dlazy-db-value\x03\x01\x01i0\
\x01p1\x01r\x02\x04names\x06values2\x04\0\x09composite\x03\03\x01r\x02\x04names\x05\
value1\x04\0\x06domain\x03\05\x01q\x03\x08included\x011\0\x08excluded\x011\0\x09\
unbounded\0\0\x04\0\x0bvalue-bound\x03\07\x01r\x02\x05start8\x03end8\x04\0\x0cva\
lues-range\x03\09\x01r\x02\x04names\x05value:\x04\0\x05range\x03\0;\x01p}\x01p\x7f\
\x01q*\x09character\x01~\0\x04int2\x01|\0\x04int4\x01z\0\x04int8\x01x\0\x06float\
4\x01v\0\x06float8\x01u\0\x07numeric\x01s\0\x07boolean\x01\x7f\0\x04text\x01s\0\x07\
varchar\x01s\0\x06bpchar\x01s\0\x09timestamp\x01\x07\0\x0btimestamptz\x01\x09\0\x04\
date\x01\x01\0\x04time\x01\x03\0\x06timetz\x01\x05\0\x08interval\x01\x13\0\x05by\
tea\x01=\0\x04json\x01s\0\x05jsonb\x01s\0\x08jsonpath\x01s\0\x03xml\x01s\0\x04uu\
id\x01\x0b\0\x04inet\x01\x0d\0\x04cidr\x01\x0d\0\x07macaddr\x01\x0f\0\x03bit\x01\
>\0\x06varbit\x01>\0\x09int4range\x01!\0\x09int8range\x01#\0\x08numrange\x01%\0\x07\
tsrange\x01'\0\x09tstzrange\x01)\0\x09daterange\x01+\0\x05money\x01x\0\x03oid\x01\
y\0\x0benumeration\x01/\0\x09composite\x014\0\x06domain\x016\0\x05array\x012\0\x05\
range\x01<\0\x04null\0\0\x04\0\x08db-value\x03\0?\x04\0\x13lazy-db-column-type\x03\
\x01\x01iA\x01o\x02s\xc2\0\x01p\xc3\0\x01r\x02\x04names\x0aattributes\xc4\0\x04\0\
\x0ecomposite-type\x03\0E\x01r\x02\x04names\x09base-type\xc2\0\x04\0\x0bdomain-t\
ype\x03\0G\x01r\x02\x04names\x09base-type\xc2\0\x04\0\x0arange-type\x03\0I\x01q)\
\x09character\0\0\x04int2\0\0\x04int4\0\0\x04int8\0\0\x06float4\0\0\x06float8\0\0\
\x07numeric\0\0\x07boolean\0\0\x04text\0\0\x07varchar\0\0\x06bpchar\0\0\x09times\
tamp\0\0\x0btimestamptz\0\0\x04date\0\0\x04time\0\0\x06timetz\0\0\x08interval\0\0\
\x05bytea\0\0\x04uuid\0\0\x03xml\0\0\x04json\0\0\x05jsonb\0\0\x08jsonpath\0\0\x04\
inet\0\0\x04cidr\0\0\x07macaddr\0\0\x03bit\0\0\x06varbit\0\0\x09int4range\0\0\x09\
int8range\0\0\x08numrange\0\0\x07tsrange\0\0\x09tstzrange\0\0\x09daterange\0\0\x05\
money\0\0\x03oid\0\0\x0benumeration\x01-\0\x09composite\x01\xc6\0\0\x06domain\x01\
\xc8\0\0\x05array\x01\xc2\0\0\x05range\x01\xca\0\0\x04\0\x0edb-column-type\x03\0\
K\x01r\x04\x07ordinalw\x04names\x07db-type\xcc\0\x0cdb-type-names\x04\0\x09db-co\
lumn\x03\0M\x01p\xc0\0\x01r\x01\x06values\xcf\0\x04\0\x06db-row\x03\0P\x01p\xce\0\
\x01p\xd1\0\x01r\x02\x07columns\xd2\0\x04rows\xd3\0\x04\0\x09db-result\x03\0T\x04\
\0\x10db-result-stream\x03\x01\x04\0\x0ddb-connection\x03\x01\x04\0\x0edb-transa\
ction\x03\x01\x01@\x01\x05value\xc0\0\01\x04\0\x1a[constructor]lazy-db-value\x01\
Y\x01h0\x01@\x01\x04self\xda\0\0\xc0\0\x04\0\x19[method]lazy-db-value.get\x01[\x01\
@\x01\x05value\xcc\0\0\xc2\0\x04\0\x20[constructor]lazy-db-column-type\x01\\\x01\
hA\x01@\x01\x04self\xdd\0\0\xcc\0\x04\0\x1f[method]lazy-db-column-type.get\x01^\x01\
hV\x01@\x01\x04self\xdf\0\0\xd2\0\x04\0$[method]db-result-stream.get-columns\x01\
`\x01k\xd3\0\x01@\x01\x04self\xdf\0\0\xe1\0\x04\0![method]db-result-stream.get-n\
ext\x01b\x01iW\x01j\x01\xe3\0\x01\x11\x01@\x01\x07addresss\0\xe4\0\x04\0\x1a[sta\
tic]db-connection.open\x01e\x01hW\x01j\x01\xd5\0\x01\x11\x01@\x03\x04self\xe6\0\x09\
statements\x06params\xcf\0\0\xe7\0\x04\0\x1b[method]db-connection.query\x01h\x01\
iV\x01j\x01\xe9\0\x01\x11\x01@\x03\x04self\xe6\0\x09statements\x06params\xcf\0\0\
\xea\0\x04\0\"[method]db-connection.query-stream\x01k\x01j\x01w\x01\x11\x01@\x03\
\x04self\xe6\0\x09statements\x06params\xcf\0\0\xec\0\x04\0\x1d[method]db-connect\
ion.execute\x01m\x01iX\x01j\x01\xee\0\x01\x11\x01@\x01\x04self\xe6\0\0\xef\0\x04\
\0'[method]db-connection.begin-transaction\x01p\x01hX\x01@\x03\x04self\xf1\0\x09\
statements\x06params\xcf\0\0\xe7\0\x04\0\x1c[method]db-transaction.query\x01r\x01\
@\x03\x04self\xf1\0\x09statements\x06params\xcf\0\0\xea\0\x04\0#[method]db-trans\
action.query-stream\x01s\x01@\x03\x04self\xf1\0\x09statements\x06params\xcf\0\0\xec\
\0\x04\0\x1e[method]db-transaction.execute\x01t\x01j\0\x01\x11\x01@\x01\x04self\xf1\
\0\0\xf5\0\x04\0\x1d[method]db-transaction.commit\x01v\x04\0\x1f[method]db-trans\
action.rollback\x01v\x03\0\x1agolem:rdbms/postgres@0.0.1\x05%\x01B\x04\x04\0\x05\
error\x03\x01\x01h\0\x01@\x01\x04self\x01\0s\x04\0\x1d[method]error.to-debug-str\
ing\x01\x02\x03\0\x13wasi:io/error@0.2.0\x05&\x02\x03\0\x0b\x05error\x01B(\x02\x03\
\x02\x01'\x04\0\x05error\x03\0\0\x02\x03\x02\x01\x03\x04\0\x08pollable\x03\0\x02\
\x01i\x01\x01q\x02\x15last-operation-failed\x01\x04\0\x06closed\0\0\x04\0\x0cstr\
eam-error\x03\0\x05\x04\0\x0cinput-stream\x03\x01\x04\0\x0doutput-stream\x03\x01\
\x01h\x07\x01p}\x01j\x01\x0a\x01\x06\x01@\x02\x04self\x09\x03lenw\0\x0b\x04\0\x19\
[method]input-stream.read\x01\x0c\x04\0\"[method]input-stream.blocking-read\x01\x0c\
\x01j\x01w\x01\x06\x01@\x02\x04self\x09\x03lenw\0\x0d\x04\0\x19[method]input-str\
eam.skip\x01\x0e\x04\0\"[method]input-stream.blocking-skip\x01\x0e\x01i\x03\x01@\
\x01\x04self\x09\0\x0f\x04\0\x1e[method]input-stream.subscribe\x01\x10\x01h\x08\x01\
@\x01\x04self\x11\0\x0d\x04\0![method]output-stream.check-write\x01\x12\x01j\0\x01\
\x06\x01@\x02\x04self\x11\x08contents\x0a\0\x13\x04\0\x1b[method]output-stream.w\
rite\x01\x14\x04\0.[method]output-stream.blocking-write-and-flush\x01\x14\x01@\x01\
\x04self\x11\0\x13\x04\0\x1b[method]output-stream.flush\x01\x15\x04\0$[method]ou\
tput-stream.blocking-flush\x01\x15\x01@\x01\x04self\x11\0\x0f\x04\0\x1f[method]o\
utput-stream.subscribe\x01\x16\x01@\x02\x04self\x11\x03lenw\0\x13\x04\0\"[method\
]output-stream.write-zeroes\x01\x17\x04\05[method]output-stream.blocking-write-z\
eroes-and-flush\x01\x17\x01@\x03\x04self\x11\x03src\x09\x03lenw\0\x0d\x04\0\x1c[\
method]output-stream.splice\x01\x18\x04\0%[method]output-stream.blocking-splice\x01\
\x18\x03\0\x15wasi:io/streams@0.2.0\x05(\x02\x03\0\x0c\x0cinput-stream\x02\x03\0\
\x0c\x0doutput-stream\x01B+\x02\x03\x02\x01)\x04\0\x0cinput-stream\x03\0\0\x02\x03\
\x02\x01*\x04\0\x0doutput-stream\x03\0\x02\x01s\x04\0\x0econtainer-name\x03\0\x04\
\x01s\x04\0\x0bobject-name\x03\0\x06\x01w\x04\0\x09timestamp\x03\0\x08\x01w\x04\0\
\x0bobject-size\x03\0\x0a\x01s\x04\0\x05error\x03\0\x0c\x01r\x02\x04name\x05\x0a\
created-at\x09\x04\0\x12container-metadata\x03\0\x0e\x01r\x04\x04name\x07\x09con\
tainer\x05\x0acreated-at\x09\x04size\x0b\x04\0\x0fobject-metadata\x03\0\x10\x01r\
\x02\x09container\x05\x06object\x07\x04\0\x09object-id\x03\0\x12\x04\0\x0eoutgoi\
ng-value\x03\x01\x04\0\x0eincoming-value\x03\x01\x04\0\x19incoming-value-async-b\
ody\x03\0\x01\x01p}\x04\0\x18incoming-value-sync-body\x03\0\x17\x01i\x14\x01@\0\0\
\x19\x04\0)[static]outgoing-value.new-outgoing-value\x01\x1a\x01h\x14\x01i\x03\x01\
j\x01\x1c\0\x01@\x01\x04self\x1b\0\x1d\x04\00[method]outgoing-value.outgoing-val\
ue-write-body\x01\x1e\x01h\x15\x01j\x01\x18\x01\x0d\x01@\x01\x04self\x1f\0\x20\x04\
\02[method]incoming-value.incoming-value-consume-sync\x01!\x01i\x16\x01j\x01\"\x01\
\x0d\x01@\x01\x04self\x1f\0#\x04\03[method]incoming-value.incoming-value-consume\
-async\x01$\x01@\x01\x04self\x1f\0w\x04\0\x1b[method]incoming-value.size\x01%\x03\
\0\x14wasi:blobstore/types\x05+\x02\x03\0\x0d\x12container-metadata\x02\x03\0\x0d\
\x05error\x02\x03\0\x0d\x0eincoming-value\x02\x03\0\x0d\x0fobject-metadata\x02\x03\
\0\x0d\x0bobject-name\x02\x03\0\x0d\x0eoutgoing-value\x01B;\x02\x03\x02\x01)\x04\
\0\x0cinput-stream\x03\0\0\x02\x03\x02\x01*\x04\0\x0doutput-stream\x03\0\x02\x02\
\x03\x02\x01,\x04\0\x12container-metadata\x03\0\x04\x02\x03\x02\x01-\x04\0\x05er\
ror\x03\0\x06\x02\x03\x02\x01.\x04\0\x0eincoming-value\x03\0\x08\x02\x03\x02\x01\
/\x04\0\x0fobject-metadata\x03\0\x0a\x02\x03\x02\x010\x04\0\x0bobject-name\x03\0\
\x0c\x02\x03\x02\x011\x04\0\x0eoutgoing-value\x03\0\x0e\x04\0\x09container\x03\x01\
\x04\0\x13stream-object-names\x03\x01\x01h\x10\x01j\x01s\x01\x07\x01@\x01\x04sel\
f\x12\0\x13\x04\0\x16[method]container.name\x01\x14\x01j\x01\x05\x01\x07\x01@\x01\
\x04self\x12\0\x15\x04\0\x16[method]container.info\x01\x16\x01i\x09\x01j\x01\x17\
\x01\x07\x01@\x04\x04self\x12\x04name\x0d\x05startw\x03endw\0\x18\x04\0\x1a[meth\
od]container.get-data\x01\x19\x01h\x0f\x01j\0\x01\x07\x01@\x03\x04self\x12\x04na\
me\x0d\x04data\x1a\0\x1b\x04\0\x1c[method]container.write-data\x01\x1c\x01i\x11\x01\
j\x01\x1d\x01\x07\x01@\x01\x04self\x12\0\x1e\x04\0\x1e[method]container.list-obj\
ects\x01\x1f\x01@\x02\x04self\x12\x04name\x0d\0\x1b\x04\0\x1f[method]container.d\
elete-object\x01\x20\x01p\x0d\x01@\x02\x04self\x12\x05names!\0\x1b\x04\0\x20[met\
hod]container.delete-objects\x01\"\x01j\x01\x7f\x01\x07\x01@\x02\x04self\x12\x04\
name\x0d\0#\x04\0\x1c[method]container.has-object\x01$\x01j\x01\x0b\x01\x07\x01@\
\x02\x04self\x12\x04name\x0d\0%\x04\0\x1d[method]container.object-info\x01&\x01@\
\x01\x04self\x12\0\x1b\x04\0\x17[method]container.clear\x01'\x01h\x11\x01o\x02!\x7f\
\x01j\x01)\x01\x07\x01@\x02\x04self(\x03lenw\0*\x04\04[method]stream-object-name\
s.read-stream-object-names\x01+\x01o\x02w\x7f\x01j\x01,\x01\x07\x01@\x02\x04self\
(\x03numw\0-\x04\04[method]stream-object-names.skip-stream-object-names\x01.\x03\
\0\x18wasi:blobstore/container\x052\x02\x03\0\x0e\x09container\x02\x03\0\x0d\x0e\
container-name\x02\x03\0\x0d\x09object-id\x01B\x16\x02\x03\x02\x013\x04\0\x09con\
tainer\x03\0\0\x02\x03\x02\x01-\x04\0\x05error\x03\0\x02\x02\x03\x02\x014\x04\0\x0e\
container-name\x03\0\x04\x02\x03\x02\x015\x04\0\x09object-id\x03\0\x06\x01i\x01\x01\
j\x01\x08\x01\x03\x01@\x01\x04name\x05\0\x09\x04\0\x10create-container\x01\x0a\x04\
\0\x0dget-container\x01\x0a\x01j\0\x01\x03\x01@\x01\x04name\x05\0\x0b\x04\0\x10d\
elete-container\x01\x0c\x01j\x01\x7f\x01\x03\x01@\x01\x04name\x05\0\x0d\x04\0\x10\
container-exists\x01\x0e\x01@\x02\x03src\x07\x04dest\x07\0\x0b\x04\0\x0bcopy-obj\
ect\x01\x0f\x04\0\x0bmove-object\x01\x0f\x03\0\x18wasi:blobstore/blobstore\x056\x02\
\x03\0\x0c\x05error\x01Br\x02\x03\x02\x01)\x04\0\x0cinput-stream\x03\0\0\x02\x03\
\x02\x01*\x04\0\x0doutput-stream\x03\0\x02\x02\x03\x02\x017\x04\0\x05error\x03\0\
\x04\x02\x03\x02\x01\x02\x04\0\x08datetime\x03\0\x06\x01w\x04\0\x08filesize\x03\0\
\x08\x01m\x08\x07unknown\x0cblock-device\x10character-device\x09directory\x04fif\
o\x0dsymbolic-link\x0cregular-file\x06socket\x04\0\x0fdescriptor-type\x03\0\x0a\x01\
n\x06\x04read\x05write\x13file-integrity-sync\x13data-integrity-sync\x14requeste\
d-write-sync\x10mutate-directory\x04\0\x10descriptor-flags\x03\0\x0c\x01n\x01\x0e\
symlink-follow\x04\0\x0apath-flags\x03\0\x0e\x01n\x04\x06create\x09directory\x09\
exclusive\x08truncate\x04\0\x0aopen-flags\x03\0\x10\x01w\x04\0\x0alink-count\x03\
\0\x12\x01k\x07\x01r\x06\x04type\x0b\x0alink-count\x13\x04size\x09\x15data-acces\
s-timestamp\x14\x1bdata-modification-timestamp\x14\x17status-change-timestamp\x14\
\x04\0\x0fdescriptor-stat\x03\0\x15\x01q\x03\x09no-change\0\0\x03now\0\0\x09time\
stamp\x01\x07\0\x04\0\x0dnew-timestamp\x03\0\x17\x01r\x02\x04type\x0b\x04names\x04\
\0\x0fdirectory-entry\x03\0\x19\x01m%\x06access\x0bwould-block\x07already\x0ebad\
-descriptor\x04busy\x08deadlock\x05quota\x05exist\x0efile-too-large\x15illegal-b\
yte-sequence\x0bin-progress\x0binterrupted\x07invalid\x02io\x0cis-directory\x04l\
oop\x0etoo-many-links\x0cmessage-size\x0dname-too-long\x09no-device\x08no-entry\x07\
no-lock\x13insufficient-memory\x12insufficient-space\x0dnot-directory\x09not-emp\
ty\x0fnot-recoverable\x0bunsupported\x06no-tty\x0eno-such-device\x08overflow\x0d\
not-permitted\x04pipe\x09read-only\x0cinvalid-seek\x0etext-file-busy\x0ccross-de\
vice\x04\0\x0aerror-code\x03\0\x1b\x01m\x06\x06normal\x0asequential\x06random\x09\
will-need\x09dont-need\x08no-reuse\x04\0\x06advice\x03\0\x1d\x01r\x02\x05lowerw\x05\
upperw\x04\0\x13metadata-hash-value\x03\0\x1f\x04\0\x0adescriptor\x03\x01\x04\0\x16\
directory-entry-stream\x03\x01\x01h!\x01i\x01\x01j\x01$\x01\x1c\x01@\x02\x04self\
#\x06offset\x09\0%\x04\0\"[method]descriptor.read-via-stream\x01&\x01i\x03\x01j\x01\
'\x01\x1c\x01@\x02\x04self#\x06offset\x09\0(\x04\0#[method]descriptor.write-via-\
stream\x01)\x01@\x01\x04self#\0(\x04\0$[method]descriptor.append-via-stream\x01*\
\x01j\0\x01\x1c\x01@\x04\x04self#\x06offset\x09\x06length\x09\x06advice\x1e\0+\x04\
\0\x19[method]descriptor.advise\x01,\x01@\x01\x04self#\0+\x04\0\x1c[method]descr\
iptor.sync-data\x01-\x01j\x01\x0d\x01\x1c\x01@\x01\x04self#\0.\x04\0\x1c[method]\
descriptor.get-flags\x01/\x01j\x01\x0b\x01\x1c\x01@\x01\x04self#\00\x04\0\x1b[me\
thod]descriptor.get-type\x011\x01@\x02\x04self#\x04size\x09\0+\x04\0\x1b[method]\
descriptor.set-size\x012\x01@\x03\x04self#\x15data-access-timestamp\x18\x1bdata-\
modification-timestamp\x18\0+\x04\0\x1c[method]descriptor.set-times\x013\x01p}\x01\
o\x024\x7f\x01j\x015\x01\x1c\x01@\x03\x04self#\x06length\x09\x06offset\x09\06\x04\
\0\x17[method]descriptor.read\x017\x01j\x01\x09\x01\x1c\x01@\x03\x04self#\x06buf\
fer4\x06offset\x09\08\x04\0\x18[method]descriptor.write\x019\x01i\"\x01j\x01:\x01\
\x1c\x01@\x01\x04self#\0;\x04\0![method]descriptor.read-directory\x01<\x04\0\x17\
[method]descriptor.sync\x01-\x01@\x02\x04self#\x04paths\0+\x04\0&[method]descrip\
tor.create-directory-at\x01=\x01j\x01\x16\x01\x1c\x01@\x01\x04self#\0>\x04\0\x17\
[method]descriptor.stat\x01?\x01@\x03\x04self#\x0apath-flags\x0f\x04paths\0>\x04\
\0\x1a[method]descriptor.stat-at\x01@\x01@\x05\x04self#\x0apath-flags\x0f\x04pat\
hs\x15data-access-timestamp\x18\x1bdata-modification-timestamp\x18\0+\x04\0\x1f[\
method]descriptor.set-times-at\x01A\x01@\x05\x04self#\x0eold-path-flags\x0f\x08o\
ld-paths\x0enew-descriptor#\x08new-paths\0+\x04\0\x1a[method]descriptor.link-at\x01\
B\x01i!\x01j\x01\xc3\0\x01\x1c\x01@\x05\x04self#\x0apath-flags\x0f\x04paths\x0ao\
pen-flags\x11\x05flags\x0d\0\xc4\0\x04\0\x1a[method]descriptor.open-at\x01E\x01j\
\x01s\x01\x1c\x01@\x02\x04self#\x04paths\0\xc6\0\x04\0\x1e[method]descriptor.rea\
dlink-at\x01G\x04\0&[method]descriptor.remove-directory-at\x01=\x01@\x04\x04self\
#\x08old-paths\x0enew-descriptor#\x08new-paths\0+\x04\0\x1c[method]descriptor.re\
name-at\x01H\x01@\x03\x04self#\x08old-paths\x08new-paths\0+\x04\0\x1d[method]des\
criptor.symlink-at\x01I\x04\0![method]descriptor.unlink-file-at\x01=\x01@\x02\x04\
self#\x05other#\0\x7f\x04\0![method]descriptor.is-same-object\x01J\x01j\x01\x20\x01\
\x1c\x01@\x01\x04self#\0\xcb\0\x04\0\x20[method]descriptor.metadata-hash\x01L\x01\
@\x03\x04self#\x0apath-flags\x0f\x04paths\0\xcb\0\x04\0#[method]descriptor.metad\
ata-hash-at\x01M\x01h\"\x01k\x1a\x01j\x01\xcf\0\x01\x1c\x01@\x01\x04self\xce\0\0\
\xd0\0\x04\03[method]directory-entry-stream.read-directory-entry\x01Q\x01h\x05\x01\
k\x1c\x01@\x01\x03err\xd2\0\0\xd3\0\x04\0\x15filesystem-error-code\x01T\x03\0\x1b\
wasi:filesystem/types@0.2.0\x058\x02\x03\0\x10\x0adescriptor\x01B\x07\x02\x03\x02\
\x019\x04\0\x0adescriptor\x03\0\0\x01i\x01\x01o\x02\x02s\x01p\x03\x01@\0\0\x04\x04\
\0\x0fget-directories\x01\x05\x03\0\x1ewasi:filesystem/preopens@0.2.0\x05:\x01B\xc0\
\x01\x02\x03\x02\x01\x08\x04\0\x08duration\x03\0\0\x02\x03\x02\x01)\x04\0\x0cinp\
ut-stream\x03\0\x02\x02\x03\x02\x01*\x04\0\x0doutput-stream\x03\0\x04\x02\x03\x02\
\x01'\x04\0\x08io-error\x03\0\x06\x02\x03\x02\x01\x03\x04\0\x08pollable\x03\0\x08\
\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\x0a\x01q\x03\x04HTTP\0\0\x05HTTPS\0\0\x05other\x01s\0\x04\0\x06scheme\x03\0\x0c\
\x01ks\x01k{\x01r\x02\x05rcode\x0e\x09info-code\x0f\x04\0\x11DNS-error-payload\x03\
\0\x10\x01k}\x01r\x02\x08alert-id\x12\x0dalert-message\x0e\x04\0\x1aTLS-alert-re\
ceived-payload\x03\0\x13\x01ky\x01r\x02\x0afield-name\x0e\x0afield-size\x15\x04\0\
\x12field-size-payload\x03\0\x16\x01kw\x01k\x17\x01q'\x0bDNS-timeout\0\0\x09DNS-\
error\x01\x11\0\x15destination-not-found\0\0\x17destination-unavailable\0\0\x19d\
estination-IP-prohibited\0\0\x19destination-IP-unroutable\0\0\x12connection-refu\
sed\0\0\x15connection-terminated\0\0\x12connection-timeout\0\0\x17connection-rea\
d-timeout\0\0\x18connection-write-timeout\0\0\x18connection-limit-reached\0\0\x12\
TLS-protocol-error\0\0\x15TLS-certificate-error\0\0\x12TLS-alert-received\x01\x14\
\0\x13HTTP-request-denied\0\0\x1cHTTP-request-length-required\0\0\x16HTTP-reques\
t-body-size\x01\x18\0\x1bHTTP-request-method-invalid\0\0\x18HTTP-request-URI-inv\
alid\0\0\x19HTTP-request-URI-too-long\0\0\x20HTTP-request-header-section-size\x01\
\x15\0\x18HTTP-request-header-size\x01\x19\0!HTTP-request-trailer-section-size\x01\
\x15\0\x19HTTP-request-trailer-size\x01\x17\0\x18HTTP-response-incomplete\0\0!HT\
TP-response-header-section-size\x01\x15\0\x19HTTP-response-header-size\x01\x17\0\
\x17HTTP-response-body-size\x01\x18\0\"HTTP-response-trailer-section-size\x01\x15\
\0\x1aHTTP-response-trailer-size\x01\x17\0\x1dHTTP-response-transfer-coding\x01\x0e\
\0\x1cHTTP-response-content-coding\x01\x0e\0\x15HTTP-response-timeout\0\0\x13HTT\
P-upgrade-failed\0\0\x13HTTP-protocol-error\0\0\x0dloop-detected\0\0\x13configur\
ation-error\0\0\x0einternal-error\x01\x0e\0\x04\0\x0aerror-code\x03\0\x1a\x01q\x03\
\x0einvalid-syntax\0\0\x09forbidden\0\0\x09immutable\0\0\x04\0\x0cheader-error\x03\
\0\x1c\x01s\x04\0\x09field-key\x03\0\x1e\x01p}\x04\0\x0bfield-value\x03\0\x20\x04\
\0\x06fields\x03\x01\x04\0\x07headers\x03\0\"\x04\0\x08trailers\x03\0\"\x04\0\x10\
incoming-request\x03\x01\x04\0\x10outgoing-request\x03\x01\x04\0\x0frequest-opti\
ons\x03\x01\x04\0\x11response-outparam\x03\x01\x01{\x04\0\x0bstatus-code\x03\0)\x04\
\0\x11incoming-response\x03\x01\x04\0\x0dincoming-body\x03\x01\x04\0\x0ffuture-t\
railers\x03\x01\x04\0\x11outgoing-response\x03\x01\x04\0\x0doutgoing-body\x03\x01\
\x04\0\x18future-incoming-response\x03\x01\x01i\"\x01@\0\01\x04\0\x13[constructo\
r]fields\x012\x01o\x02\x1f!\x01p3\x01j\x011\x01\x1d\x01@\x01\x07entries4\05\x04\0\
\x18[static]fields.from-list\x016\x01h\"\x01p!\x01@\x02\x04self7\x04name\x1f\08\x04\
\0\x12[method]fields.get\x019\x01@\x02\x04self7\x04name\x1f\0\x7f\x04\0\x12[meth\
od]fields.has\x01:\x01j\0\x01\x1d\x01@\x03\x04self7\x04name\x1f\x05value8\0;\x04\
\0\x12[method]fields.set\x01<\x01@\x02\x04self7\x04name\x1f\0;\x04\0\x15[method]\
fields.delete\x01=\x01@\x03\x04self7\x04name\x1f\x05value!\0;\x04\0\x15[method]f\
ields.append\x01>\x01@\x01\x04self7\04\x04\0\x16[method]fields.entries\x01?\x01@\
\x01\x04self7\01\x04\0\x14[method]fields.clone\x01@\x01h%\x01@\x01\x04self\xc1\0\
\0\x0b\x04\0\x1f[method]incoming-request.method\x01B\x01@\x01\x04self\xc1\0\0\x0e\
\x04\0([method]incoming-request.path-with-query\x01C\x01k\x0d\x01@\x01\x04self\xc1\
\0\0\xc4\0\x04\0\x1f[method]incoming-request.scheme\x01E\x04\0\"[method]incoming\
-request.authority\x01C\x01i#\x01@\x01\x04self\xc1\0\0\xc6\0\x04\0\x20[method]in\
coming-request.headers\x01G\x01i,\x01j\x01\xc8\0\0\x01@\x01\x04self\xc1\0\0\xc9\0\
\x04\0\x20[method]incoming-request.consume\x01J\x01i&\x01@\x01\x07headers\xc6\0\0\
\xcb\0\x04\0\x1d[constructor]outgoing-request\x01L\x01h&\x01i/\x01j\x01\xce\0\0\x01\
@\x01\x04self\xcd\0\0\xcf\0\x04\0\x1d[method]outgoing-request.body\x01P\x01@\x01\
\x04self\xcd\0\0\x0b\x04\0\x1f[method]outgoing-request.method\x01Q\x01j\0\0\x01@\
\x02\x04self\xcd\0\x06method\x0b\0\xd2\0\x04\0#[method]outgoing-request.set-meth\
od\x01S\x01@\x01\x04self\xcd\0\0\x0e\x04\0([method]outgoing-request.path-with-qu\
ery\x01T\x01@\x02\x04self\xcd\0\x0fpath-with-query\x0e\0\xd2\0\x04\0,[method]out\
going-request.set-path-with-query\x01U\x01@\x01\x04self\xcd\0\0\xc4\0\x04\0\x1f[\
method]outgoing-request.scheme\x01V\x01@\x02\x04self\xcd\0\x06scheme\xc4\0\0\xd2\
\0\x04\0#[method]outgoing-request.set-scheme\x01W\x04\0\"[method]outgoing-reques\
t.authority\x01T\x01@\x02\x04self\xcd\0\x09authority\x0e\0\xd2\0\x04\0&[method]o\
utgoing-request.set-authority\x01X\x01@\x01\x04self\xcd\0\0\xc6\0\x04\0\x20[meth\
od]outgoing-request.headers\x01Y\x01i'\x01@\0\0\xda\0\x04\0\x1c[constructor]requ\
est-options\x01[\x01h'\x01k\x01\x01@\x01\x04self\xdc\0\0\xdd\0\x04\0'[method]req\
uest-options.connect-timeout\x01^\x01@\x02\x04self\xdc\0\x08duration\xdd\0\0\xd2\
\0\x04\0+[method]request-options.set-connect-timeout\x01_\x04\0*[method]request-\
options.first-byte-timeout\x01^\x04\0.[method]request-options.set-first-byte-tim\
eout\x01_\x04\0-[method]request-options.between-bytes-timeout\x01^\x04\01[method\
]request-options.set-between-bytes-timeout\x01_\x01i(\x01i.\x01j\x01\xe1\0\x01\x1b\
\x01@\x02\x05param\xe0\0\x08response\xe2\0\x01\0\x04\0\x1d[static]response-outpa\
ram.set\x01c\x01h+\x01@\x01\x04self\xe4\0\0*\x04\0\x20[method]incoming-response.\
status\x01e\x01@\x01\x04self\xe4\0\0\xc6\0\x04\0![method]incoming-response.heade\
rs\x01f\x01@\x01\x04self\xe4\0\0\xc9\0\x04\0![method]incoming-response.consume\x01\
g\x01h,\x01i\x03\x01j\x01\xe9\0\0\x01@\x01\x04self\xe8\0\0\xea\0\x04\0\x1c[metho\
d]incoming-body.stream\x01k\x01i-\x01@\x01\x04this\xc8\0\0\xec\0\x04\0\x1c[stati\
c]incoming-body.finish\x01m\x01h-\x01i\x09\x01@\x01\x04self\xee\0\0\xef\0\x04\0!\
[method]future-trailers.subscribe\x01p\x01i$\x01k\xf1\0\x01j\x01\xf2\0\x01\x1b\x01\
j\x01\xf3\0\0\x01k\xf4\0\x01@\x01\x04self\xee\0\0\xf5\0\x04\0\x1b[method]future-\
trailers.get\x01v\x01@\x01\x07headers\xc6\0\0\xe1\0\x04\0\x1e[constructor]outgoi\
ng-response\x01w\x01h.\x01@\x01\x04self\xf8\0\0*\x04\0%[method]outgoing-response\
.status-code\x01y\x01@\x02\x04self\xf8\0\x0bstatus-code*\0\xd2\0\x04\0)[method]o\
utgoing-response.set-status-code\x01z\x01@\x01\x04self\xf8\0\0\xc6\0\x04\0![meth\
od]outgoing-response.headers\x01{\x01@\x01\x04self\xf8\0\0\xcf\0\x04\0\x1e[metho\
d]outgoing-response.body\x01|\x01h/\x01i\x05\x01j\x01\xfe\0\0\x01@\x01\x04self\xfd\
\0\0\xff\0\x04\0\x1b[method]outgoing-body.write\x01\x80\x01\x01j\0\x01\x1b\x01@\x02\
\x04this\xce\0\x08trailers\xf2\0\0\x81\x01\x04\0\x1c[static]outgoing-body.finish\
\x01\x82\x01\x01h0\x01@\x01\x04self\x83\x01\0\xef\0\x04\0*[method]future-incomin\
g-response.subscribe\x01\x84\x01\x01i+\x01j\x01\x85\x01\x01\x1b\x01j\x01\x86\x01\
\0\x01k\x87\x01\x01@\x01\x04self\x83\x01\0\x88\x01\x04\0$[method]future-incoming\
-response.get\x01\x89\x01\x01h\x07\x01k\x1b\x01@\x01\x03err\x8a\x01\0\x8b\x01\x04\
\0\x0fhttp-error-code\x01\x8c\x01\x03\0\x15wasi:http/types@0.2.0\x05;\x02\x03\0\x12\
\x10outgoing-request\x02\x03\0\x12\x0frequest-options\x02\x03\0\x12\x18future-in\
coming-response\x02\x03\0\x12\x0aerror-code\x01B\x0f\x02\x03\x02\x01<\x04\0\x10o\
utgoing-request\x03\0\0\x02\x03\x02\x01=\x04\0\x0frequest-options\x03\0\x02\x02\x03\
\x02\x01>\x04\0\x18future-incoming-response\x03\0\x04\x02\x03\x02\x01?\x04\0\x0a\
error-code\x03\0\x06\x01i\x01\x01i\x03\x01k\x09\x01i\x05\x01j\x01\x0b\x01\x07\x01\
@\x02\x07request\x08\x07options\x0a\0\x0c\x04\0\x06handle\x01\x0d\x03\0\x20wasi:\
http/outgoing-handler@0.2.0\x05@\x01B\x04\x04\0\x05error\x03\x01\x01h\0\x01@\x01\
\x04self\x01\0s\x04\0\x13[method]error.trace\x01\x02\x03\0'wasi:keyvalue/wasi-ke\
yvalue-error@0.1.0\x05A\x02\x03\0\x14\x05error\x01B,\x02\x03\x02\x01)\x04\0\x0ci\
nput-stream\x03\0\0\x02\x03\x02\x01*\x04\0\x0doutput-stream\x03\0\x02\x02\x03\x02\
\x01B\x04\0\x05error\x03\0\x04\x04\0\x06bucket\x03\x01\x01s\x04\0\x03key\x03\0\x07\
\x04\0\x0eoutgoing-value\x03\x01\x04\0\x19outgoing-value-body-async\x03\0\x03\x01\
p}\x04\0\x18outgoing-value-body-sync\x03\0\x0b\x04\0\x0eincoming-value\x03\x01\x04\
\0\x19incoming-value-async-body\x03\0\x01\x01p}\x04\0\x18incoming-value-sync-bod\
y\x03\0\x0f\x01i\x06\x01i\x05\x01j\x01\x11\x01\x12\x01@\x01\x04names\0\x13\x04\0\
\x1a[static]bucket.open-bucket\x01\x14\x01i\x09\x01@\0\0\x15\x04\0)[static]outgo\
ing-value.new-outgoing-value\x01\x16\x01h\x09\x01i\x0a\x01j\x01\x18\x01\x12\x01@\
\x01\x04self\x17\0\x19\x04\06[method]outgoing-value.outgoing-value-write-body-as\
ync\x01\x1a\x01j\0\x01\x12\x01@\x02\x04self\x17\x05value\x0c\0\x1b\x04\05[method\
]outgoing-value.outgoing-value-write-body-sync\x01\x1c\x01h\x0d\x01j\x01\x10\x01\
\x12\x01@\x01\x04self\x1d\0\x1e\x04\02[method]incoming-value.incoming-value-cons\
ume-sync\x01\x1f\x01i\x0e\x01j\x01\x20\x01\x12\x01@\x01\x04self\x1d\0!\x04\03[me\
thod]incoming-value.incoming-value-consume-async\x01\"\x01j\x01w\x01\x12\x01@\x01\
\x04self\x1d\0#\x04\0*[method]incoming-value.incoming-value-size\x01$\x03\0\x19w\
asi:keyvalue/types@0.1.0\x05C\x02\x03\0\x15\x06bucket\x02\x03\0\x15\x05error\x02\
\x03\0\x15\x03key\x02\x03\0\x15\x0eincoming-value\x02\x03\0\x15\x0eoutgoing-valu\
e\x01B\x1e\x02\x03\x02\x01D\x04\0\x06bucket\x03\0\0\x02\x03\x02\x01E\x04\0\x05er\
ror\x03\0\x02\x02\x03\x02\x01F\x04\0\x03key\x03\0\x04\x02\x03\x02\x01G\x04\0\x0e\
incoming-value\x03\0\x06\x02\x03\x02\x01H\x04\0\x0eoutgoing-value\x03\0\x08\x01h\
\x01\x01p\x05\x01i\x07\x01k\x0c\x01p\x0d\x01i\x03\x01j\x01\x0e\x01\x0f\x01@\x02\x06\
bucket\x0a\x04keys\x0b\0\x10\x04\0\x08get-many\x01\x11\x01j\x01\x0b\x01\x0f\x01@\
\x01\x06bucket\x0a\0\x12\x04\0\x04keys\x01\x13\x01h\x09\x01o\x02\x05\x14\x01p\x15\
\x01j\0\x01\x0f\x01@\x02\x06bucket\x0a\x0akey-values\x16\0\x17\x04\0\x08set-many\
\x01\x18\x01@\x02\x06bucket\x0a\x04keys\x0b\0\x17\x04\0\x0bdelete-many\x01\x19\x03\
\0\"wasi:keyvalue/eventual-batch@0.1.0\x05I\x01B\x1a\x02\x03\x02\x01D\x04\0\x06b\
ucket\x03\0\0\x02\x03\x02\x01E\x04\0\x05error\x03\0\x02\x02\x03\x02\x01G\x04\0\x0e\
incoming-value\x03\0\x04\x02\x03\x02\x01F\x04\0\x03key\x03\0\x06\x02\x03\x02\x01\
H\x04\0\x0eoutgoing-value\x03\0\x08\x01h\x01\x01i\x05\x01k\x0b\x01i\x03\x01j\x01\
\x0c\x01\x0d\x01@\x02\x06bucket\x0a\x03key\x07\0\x0e\x04\0\x03get\x01\x0f\x01h\x09\
\x01j\0\x01\x0d\x01@\x03\x06bucket\x0a\x03key\x07\x0eoutgoing-value\x10\0\x11\x04\
\0\x03set\x01\x12\x01@\x02\x06bucket\x0a\x03key\x07\0\x11\x04\0\x06delete\x01\x13\
\x01j\x01\x7f\x01\x0d\x01@\x02\x06bucket\x0a\x03key\x07\0\x14\x04\0\x06exists\x01\
\x15\x03\0\x1cwasi:keyvalue/eventual@0.1.0\x05J\x01B\x04\x01m\x06\x05trace\x05de\
bug\x04info\x04warn\x05error\x08critical\x04\0\x05level\x03\0\0\x01@\x03\x05leve\
l\x01\x07contexts\x07messages\x01\0\x04\0\x03log\x01\x02\x03\0\x14wasi:logging/l\
ogging\x05K\x01B\x11\x04\0\x07network\x03\x01\x01m\x15\x07unknown\x0daccess-deni\
ed\x0dnot-supported\x10invalid-argument\x0dout-of-memory\x07timeout\x14concurren\
cy-conflict\x0fnot-in-progress\x0bwould-block\x0dinvalid-state\x10new-socket-lim\
it\x14address-not-bindable\x0eaddress-in-use\x12remote-unreachable\x12connection\
-refused\x10connection-reset\x12connection-aborted\x12datagram-too-large\x11name\
-unresolvable\x1atemporary-resolver-failure\x1apermanent-resolver-failure\x04\0\x0a\
error-code\x03\0\x01\x01m\x02\x04ipv4\x04ipv6\x04\0\x11ip-address-family\x03\0\x03\
\x01o\x04}}}}\x04\0\x0cipv4-address\x03\0\x05\x01o\x08{{{{{{{{\x04\0\x0cipv6-add\
ress\x03\0\x07\x01q\x02\x04ipv4\x01\x06\0\x04ipv6\x01\x08\0\x04\0\x0aip-address\x03\
\0\x09\x01r\x02\x04port{\x07address\x06\x04\0\x13ipv4-socket-address\x03\0\x0b\x01\
r\x04\x04port{\x09flow-infoy\x07address\x08\x08scope-idy\x04\0\x13ipv6-socket-ad\
dress\x03\0\x0d\x01q\x02\x04ipv4\x01\x0c\0\x04ipv6\x01\x0e\0\x04\0\x11ip-socket-\
address\x03\0\x0f\x03\0\x1awasi:sockets/network@0.2.0\x05L\x02\x03\0\x19\x07netw\
ork\x02\x03\0\x19\x0aerror-code\x02\x03\0\x19\x0aip-address\x01B\x16\x02\x03\x02\
\x01\x03\x04\0\x08pollable\x03\0\0\x02\x03\x02\x01M\x04\0\x07network\x03\0\x02\x02\
\x03\x02\x01N\x04\0\x0aerror-code\x03\0\x04\x02\x03\x02\x01O\x04\0\x0aip-address\
\x03\0\x06\x04\0\x16resolve-address-stream\x03\x01\x01h\x08\x01k\x07\x01j\x01\x0a\
\x01\x05\x01@\x01\x04self\x09\0\x0b\x04\03[method]resolve-address-stream.resolve\
-next-address\x01\x0c\x01i\x01\x01@\x01\x04self\x09\0\x0d\x04\0([method]resolve-\
address-stream.subscribe\x01\x0e\x01h\x03\x01i\x08\x01j\x01\x10\x01\x05\x01@\x02\
\x07network\x0f\x04names\0\x11\x04\0\x11resolve-addresses\x01\x12\x03\0!wasi:soc\
kets/ip-name-lookup@0.2.0\x05P\x01B\x05\x02\x03\x02\x01M\x04\0\x07network\x03\0\0\
\x01i\x01\x01@\0\0\x02\x04\0\x10instance-network\x01\x03\x03\0#wasi:sockets/inst\
ance-network@0.2.0\x05Q\x04\0\x15golem:rust/golem-rust\x04\0\x0b\x10\x01\0\x0ago\
lem-rust\x03\0\0\0G\x09producers\x01\x0cprocessed-by\x02\x0dwit-component\x070.2\
20.0\x10wit-bindgen-rust\x060.36.0";
#[inline(never)]
#[doc(hidden)]
pub fn __link_custom_section_describing_imports() {
    wit_bindgen_rt::maybe_link_cabi_realloc();
}